LilyPond-Ruby 0.1.1 → 0.1.2

data/share/lilypond/2.24.1/scm/lily/document-translation.scm

@@ -0,0 +1,318 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2000--2022 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.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+(use-modules (ice-9 match))
+
+(define (engraver-makes-grob? name-symbol grav)
+  (memq name-symbol (assoc-get 'grobs-created (ly:translator-description grav) '())))
+
+(define (engraver-accepts-music-type? name-symbol grav)
+  (memq name-symbol (assoc 'events-accepted (ly:translator-description grav))))
+
+(define (engraver-accepts-music-types? types grav)
+  (if (null? types)
+      #f
+      (or
+       (engraver-accepts-music-type? (car types) grav)
+       (engraver-accepts-music-types? (cdr types) grav))))
+
+(define (engraver-doc-string engraver in-which-contexts)
+  (let* ((propsr (assoc-get 'properties-read (ly:translator-description engraver)))
+         (propsw (assoc-get 'properties-written (ly:translator-description engraver)))
+         (accepted  (assoc-get 'events-accepted (ly:translator-description engraver)))
+         (name-sym  (ly:translator-name engraver))
+         (name-str (symbol->string name-sym))
+         (desc (string-trim-both (assoc-get 'description (ly:translator-description engraver))))
+         (grobs (engraver-grobs engraver)))
+    (string-append
+     desc
+     "\n\n"
+     "@raggedRight\n"
+     (if (pair? accepted)
+         (string-append
+          "Music types accepted:\n"
+          (list-xref-symbols accepted))
+         "")
+     "\n\n"
+     (if (pair? propsr)
+         (string-append
+          "Properties (read)"
+          (description-list->texi
+           (map (lambda (x) (property->texi 'translation x '()))
+                (sort propsr ly:symbol-ci<?))
+           #t))
+         "")
+
+     (if (null? propsw)
+         ""
+         (string-append
+          "Properties (write)"
+          (description-list->texi
+           (map (lambda (x) (property->texi 'translation x '()))
+                (sort propsw ly:symbol-ci<?))
+           #t)))
+
+     (if  (null? grobs)
+          ""
+          (string-append
+           "\n\nThis engraver creates the following layout object(s):\n"
+           (list-xref-symbols grobs)
+           "."))
+
+     "\n\n"
+
+     (if in-which-contexts
+         (let* ((output-list
+                 (append-map
+                  (lambda (output output-name)
+                    (let* ((output-alist (ly:output-description output))
+                           (context-description-alist (map cdr output-alist))
+                           (contexts
+                            (append-map
+                             (lambda (x)
+                               (let* ((context (assoc-get 'context-name x))
+                                      (group (assq-ref x 'group-type))
+                                      (consists (append
+                                                 (if group
+                                                     (list group)
+                                                     '())
+                                                 (assoc-get 'consists x))))
+                                 (if (member name-sym consists)
+                                     (list context)
+                                     '())))
+                             context-description-alist)))
+                      (if (null? contexts)
+                          '()
+                          (list (cons output-name (list-xref-symbols contexts))))))
+                  (list $defaultlayout $defaultmidi)
+                  (list "\\layout" "\\midi"))))
+           (string-append
+            "@code{" name-str "} "
+            (if (null? output-list)
+                "is not part of any context"
+                (string-append
+                 "is part of the following context(s) "
+                 (string-join
+                  (map
+                   (lambda (elt)
+                     (string-append "in @code{" (car elt) "}: " (cdr elt)))
+                   output-list)
+                  ";\n")
+                 "."))))
+         "")
+
+     "\n@endRaggedRight")))
+
+;; First level Engraver description
+(define (engraver-doc grav)
+  (make <texi-node>
+    #:code-tag #t
+    #:name (symbol->string (ly:translator-name grav))
+    #:text (engraver-doc-string grav #t)))
+
+;; Second level, part of Context description
+(define name->engraver-table (make-hash-table 61))
+(for-each
+ (lambda (x)
+   (hash-set! name->engraver-table (ly:translator-name x) x))
+ (ly:get-all-translators))
+
+(define (find-engraver-by-name name)
+  "NAME is a symbol."
+  (hash-ref name->engraver-table name #f))
+
+(define (document-engraver-by-name name)
+  "NAME is a symbol."
+
+  (let* ((eg (find-engraver-by-name name)))
+
+    (cons (ref-ify (symbol->string name))
+          (engraver-doc-string eg #f))))
+
+(define (document-property-operation op)
+  (match op
+    (('assign property (? ly:grob-properties?))
+     ;; Ignore definitions of grobs in Global.
+     "")
+    (('assign property value)
+     (format #f "@item Set context property @code{~a} to~a"
+             property
+             (if (pretty-printable? value)
+                 (format #f ":~a\n" (scm->texi value))
+                 (format #f " ~a.\n" (scm->texi value)))))
+    (('push grob value . path)
+     (format #f "@item Set grob property @code{~{~a~^.~}} in @iref{~a} to ~a"
+             path
+             grob
+             (if (pretty-printable? value)
+                 (format #f ":~a\n" (scm->texi value))
+                 (format #f " ~a.\n" (scm->texi value)))))
+    (('unset property)
+     (format #f "@item Unset context property @code{~a}\n"
+             property))
+    (('pop grob . path)
+     (format #f "@item Revert grob property @code{~{~a~^.~}} in @iref{~a}\n"
+             path
+             grob))
+    (('apply proc)
+     (format #f "@item Apply procedure @code{~a}\n"
+             (scm->texi proc)))))
+
+
+(define (context-doc context-desc)
+  (let* ((name-sym (assoc-get 'context-name context-desc))
+         (name (symbol->string name-sym))
+         (aliases (assoc-get 'aliases context-desc))
+         (desc (assoc-get 'description context-desc "(not documented"))
+         (accepts (assoc-get 'accepts context-desc))
+         (consists (assoc-get 'consists context-desc))
+         (props (assoc-get 'property-ops context-desc))
+         (defaultchild (assoc-get 'default-child context-desc))
+         (grobs-created (context-grobs context-desc)))
+
+    (make <texi-node>
+      #:code-tag #t
+      #:name name
+      #:text
+      (string-append
+       desc
+       (if (pair? aliases)
+           (string-append
+            "\n\nThis context also accepts commands for the following context(s):\n"
+            (list-xref-symbols aliases)
+            ".")
+           "")
+
+       "\n\n@raggedRight"
+       "\nThis context creates the following layout object(s):\n"
+       (list-xref-symbols grobs-created #:uniq #t)
+       "."
+
+       (if (and (pair? props) (not (null? props)))
+           (let ((str (string-concatenate
+                       (sort (map document-property-operation props)
+                             ly:string-ci<?))))
+             (if (string-null? str)
+                 ""
+                 (string-append
+                  "\n\nThis context sets the following properties:\n\n"
+                  "@itemize @bullet\n"
+                  str
+                  "@end itemize\n")))
+           "")
+
+       "\n@endRaggedRight"
+
+       (if defaultchild
+           (format #f "\n\nThis is not a `Bottom' context; search for such a one will commence after creating an implicit context of type @iref{~a}."
+                   defaultchild)
+           "\n\nThis is a `Bottom' context; no contexts will be created implicitly from it.")
+
+       (if (null? accepts)
+           "\n\nThis context cannot contain other contexts."
+           (string-append
+            "\n\n@raggedRight"
+            "\nContext @code{"
+            name
+            "} can contain\n"
+            (list-xref-symbols accepts)
+            "."
+            "\n@endRaggedRight"))
+
+       (if (null? consists)
+           ""
+           (string-append
+            "\n\nThis context is built from the following engraver(s):"
+            (description-list->texi
+             (map document-engraver-by-name (sort consists ly:symbol-ci<?))
+             #t)))))))
+
+(define (engraver-grobs grav)
+  (let* ((eg (if (symbol? grav)
+                 (find-engraver-by-name grav)
+                 grav)))
+    (if (eq? eg #f)
+        '()
+        (assoc-get 'grobs-created (ly:translator-description eg) '()))))
+
+(define (context-grobs context-desc)
+  (let* ((group (assq-ref context-desc 'group-type))
+         (consists (append
+                    (if group
+                        (list group)
+                        '())
+                    (assoc-get 'consists context-desc)))
+         (grobs (append-map engraver-grobs consists)))
+    grobs))
+
+(define (all-contexts-doc)
+  (let* ((layout-alist
+          (sort (ly:output-description $defaultlayout)
+                (lambda (x y) (ly:symbol-ci<? (car x) (car y)))))
+         (names (sort (map symbol->string (map car layout-alist)) ly:string-ci<?))
+         (contexts (map cdr layout-alist)))
+
+    (make <texi-node>
+      #:name "Contexts"
+      #:desc "Complete descriptions of all contexts."
+      #:children
+      (map context-doc contexts))))
+
+(define all-engravers-list  (ly:get-all-translators))
+(set! all-engravers-list
+      (sort all-engravers-list
+            (lambda (a b) (ly:string-ci<? (symbol->string (ly:translator-name a))
+                                          (symbol->string (ly:translator-name b))))))
+
+(define (all-engravers-doc)
+  (make <texi-node>
+    #:name "Engravers and Performers"
+    #:desc "All separate engravers and performers."
+    #:text "See @ruser{Modifying context plug-ins}."
+    #:children
+    (map engraver-doc all-engravers-list)))
+
+(define (translation-properties-doc-string lst)
+  (let* ((ps (sort (map symbol->string lst) ly:string-ci<?))
+         (sortedsyms (map string->symbol ps))
+         (propdescs
+          (map
+           (lambda (x) (property->texi 'translation  x '()))
+           sortedsyms))
+         (texi (description-list->texi propdescs #f)))
+    texi))
+
+(define (translation-doc-node)
+  (make <texi-node>
+    #:name "Translation"
+    #:desc "From music to layout."
+    #:children
+    (list
+     (all-contexts-doc)
+     (all-engravers-doc)
+     (make <texi-node>
+       #:name "Tunable context properties"
+       #:desc "All tunable context properties."
+       #:text (translation-properties-doc-string
+               all-user-translation-properties))
+
+     (make <texi-node>
+       #:name "Internal context properties"
+       #:desc "All internal context properties."
+       #:text (translation-properties-doc-string
+               all-internal-translation-properties)))))

data/share/lilypond/2.24.1/scm/lily/document-type-predicates.scm

@@ -0,0 +1,85 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2010--2022 Mark Polesky <markpolesky@yahoo.com>
+;;;;
+;;;; 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.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+(define (document-type-predicate entry)
+  (let ((pred (procedure-name (car entry))))
+    (string-append
+     "@item @code{"
+     (case pred
+       ;; don't print "cheap-markup?"
+       ((cheap-markup?) "markup?")
+       (else (symbol->string pred)))
+     "} @tab \n"
+     (case pred
+       ;; clarify `list?' vs. `cheap-list?'
+       ((list?) "list @emph{(use} @code{cheap-list?}
+                @emph{for faster processing)}")
+       ((cheap-list?) "list @emph{(use this instead of}
+                      @code{list?} @emph{for faster processing)}")
+       (else (cdr entry)))
+     "\n")))
+
+(define (document-type-predicate-category alist nodename description)
+  (string-append
+   "@node " nodename "\n"
+   "@unnumberedsubsec " nodename "\n"
+   "\n\n"
+   description "\n\n"
+   "@multitable @columnfractions .33 .66\n"
+   "@headitem Type predicate @tab Description\n"
+   (string-concatenate
+    (sort (map document-type-predicate alist)
+          ly:string-ci<?))
+   "@end multitable\n"
+   "\n"))
+
+(define-public type-predicates-doc-string
+  (string-append
+   "Predicates return @code{#t} when their argument is of the named type
+and @code{#f} if it isn't.\n\n"
+   "@menu\n"
+   "* R5RS primary predicates::\n"
+   "* R5RS secondary predicates::\n"
+   "* Guile predicates::\n"
+   "* LilyPond scheme predicates::\n"
+   "* LilyPond exported predicates::\n"
+   "@end menu\n"
+   "\n"
+   (string-concatenate
+    (map
+     (lambda (alist-nodename-list)
+       (apply document-type-predicate-category
+              alist-nodename-list))
+     `((,r5rs-primary-predicates
+        "R5RS primary predicates"
+        "Primary predicates can be applied to any expression.  They can
+be used on their own as predicates for LilyPond functions.
+The predicates here are part of the Scheme standard R5RS.")
+       (,r5rs-secondary-predicates
+        "R5RS secondary predicates"
+        "Secondary predicates are only applicable to specific expressions
+(for example, to numbers).  They will throw a type error when applied to expressions
+they are not intended for.  The predicates here are part of the Scheme standard R5RS.")
+       (,guile-predicates
+        "Guile predicates"
+        "These predicates are defined by Guile but are not part of a Scheme standard.")
+       (,lilypond-scheme-predicates
+        "LilyPond scheme predicates"
+        "These predicates are only available within LilyPond and defined in Scheme.")
+       (,lilypond-exported-predicates
+        "LilyPond exported predicates"
+        "These predicates are only available within LilyPond and usually defined in C++."))))))

data/share/lilypond/2.24.1/scm/lily/documentation-generate.scm

@@ -0,0 +1,259 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2000--2022 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.
+;;;;
+;;;; LilyPond is distributed in the hope that it will be useful,
+;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;;;; GNU General Public License for more details.
+;;;;
+;;;; You should have received a copy of the GNU General Public License
+;;;; along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; File entry point for generated documentation
+;;; Running LilyPond on this file generates the documentation
+
+;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;; TODO : make modules of these!
+;;;;;;;;;;;;;;;;
+
+;; todo: naming: grob vs. layout property
+
+(use-modules (lily accreg) (ice-9 session))
+
+(for-each ly:load '("documentation-lib"
+                    "lily-sort"
+                    "document-functions"
+                    "document-translation"
+                    "document-music"
+                    "document-type-predicates"
+                    "document-identifiers"
+                    "document-context-mods"
+                    "document-backend"
+                    "document-markup"
+                    "document-outside-staff-priorities"
+                    "document-paper-sizes"
+                    "hyphenate-internal-words"))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;(display
+;; (markup-doc-string)
+;; (open-output-file "markup-commands.tely"))
+
+(display
+ ;; ugly hack to remove the @node... @appendixsec... portion
+ (substring
+  (call-with-output-string
+   (lambda (port)
+     (dump-node (markup-doc-node) port 2)))
+  ;; magic number to remove the initial part.  63 comes from:
+  ;; "\nnode Text markup commands\n@appendixsec Text markup commands\n\n\n\n"
+  ;; which is generated by (dump-node...) in documentation-lib.scm
+  63
+  )
+ (open-output-file "markup-commands.tely" #:encoding "UTF-8"))
+
+(display
+ (markup-list-doc-string)
+ (open-output-file "markup-list-commands.tely" #:encoding "UTF-8"))
+
+(display
+ type-predicates-doc-string
+ (open-output-file "type-predicates.tely" #:encoding "UTF-8"))
+
+(display
+ (identifiers-doc-string)
+ (open-output-file "identifiers.tely" #:encoding "UTF-8"))
+
+(display
+ context-mods-doc-string
+ (open-output-file "context-mod-identifiers.tely" #:encoding "UTF-8"))
+
+(display
+ outside-staff-priorities-doc-string
+ (open-output-file "outside-staff-priorities.tely" #:encoding "UTF-8"))
+
+(display
+ paper-sizes-doc-string
+ (open-output-file "paper-sizes.tely" #:encoding "UTF-8"))
+
+(display
+ hyphenation-rules-string
+ (open-output-file "hyphenation.itexi" #:encoding "UTF-8"))
+
+(define file-name "internals")
+(define outname (string-append file-name ".texi"))
+
+(define out-port (open-output-file outname #:encoding "UTF-8"))
+
+(writing-wip outname)
+
+;; lilypond-main is compiled if the first arg is eq? 'files
+(define bytecode-warning
+  (if (eq? 'files
+           (cadar
+            (procedure-arguments
+             (@ (lily) lilypond-main))))
+      ""
+      "
+
+@cartouche
+
+This copy of the Internals Reference identifies function
+parameters (@pxref{Scheme functions}) only by positional names:
+@var{a}, @var{b}, @var{c}, @enddots{}
+
+For meaningful parameter names, generate bytecode before
+generating the documentation.
+
+@end cartouche
+
+"))
+
+(display
+ (string-append
+  "\\input texinfo @c -*-texinfo-*-\n"
+  "@setfilename " file-name ".info\n"
+  "@settitle LilyPond Internals Reference\n"
+  "@documentencoding UTF-8\n"
+  "@documentlanguage en\n"
+  "@afourpaper\n"
+
+  "@macro manualIntro
+This manual is a technical reference for all internal elements used
+by LilyPond and all Scheme functions it provides.  This information can
+be used to create tweaks and extensions, from simple output settings
+to advanced Scheme programming.
+@end macro
+
+@macro bytecodeWarning"
+  bytecode-warning
+  "
+@end macro
+
+@c `Internals Reference' was born 2000-10-21 with this commit:
+@c patch::: 1.3.96.jcn9
+@c author: Jan Nieuwenhuizen
+@c commit: 8ecd09ad7514d57630fb611d38c161f3c3c708db
+@c   file: scm/generate-documentation.scm
+
+@macro copyrightDeclare
+Copyright @copyright{} 2000--2022 by the authors
+@end macro
+
+@dircategory LilyPond -- the music typesetter
+@direntry
+* Internals: (lilypond-internals).    Tweaking reference.
+@end direntry
+
+@include en/macros.itexi
+@iftex
+@tableindent=@itemindent
+@end iftex
+
+@c   ***** Title page *****
+
+@ifnottex")
+ out-port)
+
+(define top-node
+  (make <texi-node>
+    #:name "LilyPond -- Internals Reference"
+    #:text
+    (string-append "
+
+@cartouche
+@manualIntro{}
+@end cartouche
+
+@bytecodeWarning
+
+@end ifnottex
+
+@finalout
+
+@titlepage
+@title LilyPond
+@subtitle The music typesetter
+@titlefont{Internals Reference}
+@author The LilyPond development team
+
+@vskip 40pt
+
+@cartouche
+@manualIntro{}
+@end cartouche
+
+@vskip 10pt
+
+@bytecodeWarning
+
+@vskip 10pt
+
+@docMain{}
+
+@vskip 0pt plus 1filll
+
+@copyrightDeclare
+
+@quotation
+Permission is granted to copy, distribute and/or modify this document
+under the terms of the GNU Free Documentation License, Version 1.1
+or any later version published by the Free Software Foundation;
+with no Invariant Sections.
+@end quotation
+
+For LilyPond version @version{}
+@end titlepage
+
+@ifnottex
+
+@docMain
+@end ifnottex
+
+@contents
+
+@ifhtml
+@ifclear bigpage
+This document is also available as a
+@uref{../internals.pdf,PDF} and as
+@uref{../internals-big-page.html,one big page}.
+@end ifclear
+@ifset bigpage
+This document is also available as a
+@uref{internals.pdf,PDF} and as a
+@uref{internals/index.html,HTML indexed multiple pages}.
+@end ifset
+@end ifhtml")
+
+    #:children
+    (list
+     (music-doc-node)
+     (translation-doc-node)
+     (backend-doc-node)
+     (all-functions-doc)
+     (make <texi-node>
+       #:appendix #t
+       #:name "Indices"
+       #:text "
+@node Concept index
+@appendixsec Concept index
+
+@printindex cp
+
+@node Function index
+@appendixsec Function index
+
+@printindex fn
+
+\n@bye"))))
+
+(dump-node top-node out-port 0)
+(newline (current-error-port))