scm/document-markup.scm

   1 ;;;; document-markup.scm -- part of generated backend documentation
   2 ;;;;
   3 ;;;;  source file of the GNU LilyPond music typesetter
   4 ;;;;
   5 ;;;; (c) 1998--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
   6 ;;;;                 Jan Nieuwenhuizen <janneke@gnu.org>
   7
   8
   9 (define (doc-markup-function-properties func)
  10   (let ((properties (hashq-ref markup-functions-properties func))
  11         (prop-strings (list)))
  12     (for-each (lambda (prop-spec)
  13                 (set! prop-strings
  14                       (if (list? prop-spec)
  15                           ;; either (prop value) or (prop)
  16                           (cons (if (null? (cdr prop-spec))
  17                                     (format #f "@item @code{~a}\n" (car prop-spec))
  18                                     (format #f "@item @code{~a} (~a)\n"
  19                                             (car prop-spec)
  20                                             (let ((default (cadr prop-spec)))
  21                                               (if (and (list? default)
  22                                                        (null? default))
  23                                                   "'()"
  24                                                   default))))
  25                                 prop-strings)
  26                           ;; a markup command: get its properties
  27                           ;; FIXME: avoid cyclical references
  28                           (append (doc-markup-function-properties prop-spec)
  29                                   prop-strings))))
  30               (or properties (list)))
  31     prop-strings))
  32
  33 (define (doc-markup-function func)
  34   (let* ((doc-str  (procedure-documentation func))
  35          (f-name (symbol->string (procedure-name  func)))
  36          (c-name (regexp-substitute/global #f "-markup(-list)?$" f-name  'pre "" 'post))
  37          (sig (object-property func 'markup-signature))
  38          (arg-names (let ((arg-list (cadr (procedure-source func))))
  39                       (if (list? arg-list)
  40                           (map symbol->string (cddr arg-list))
  41                           (make-list (length sig) "arg"))))
  42          (sig-type-names (map type-name sig))
  43          (signature-str
  44           (string-join
  45            (map (lambda (x) (string-append
  46                              "@var{" (car x) "} ("  (cadr x) ")" ))
  47                 (zip arg-names  sig-type-names))
  48            " " )))
  49
  50     (string-append
  51      "\n\n@item @code{\\" c-name "} " signature-str
  52      "\n@findex \\" f-name "\n"
  53
  54      (if (string? doc-str)
  55          doc-str
  56          "")
  57      (let ((prop-strings (doc-markup-function-properties func)))
  58        (if (null? prop-strings)
  59            "\n"
  60            (string-append "\n\n\nUsed properties:\n@itemize\n"
  61                           (apply string-append prop-strings)
  62                           "@end itemize\n"))))))
  63
  64 (define (markup-function<? a b)
  65   (string<? (symbol->string (procedure-name a)) (symbol->string (procedure-name b))))
  66
  67 (define (markup-category-doc-node category)
  68   (let* ((category-string (symbol->string category))
  69          (category-name (string-capitalize (regexp-substitute/global #f
  70                                         "-" category-string 'pre " " 'post)))
  71         (markup-functions (hashq-ref markup-functions-by-category
  72                                           category)))
  73     (make <texi-node>
  74       #:name category-name
  75       #:desc ""
  76       #:text (string-append
  77               "@table @asis"
  78               (apply string-append
  79                      (map doc-markup-function
  80                           (sort markup-functions markup-function<?)))
  81               "\n@end table"))))
  82
  83 (define (markup-list-doc-string)
  84   (string-append
  85    "@table @asis"
  86    (apply string-append
  87           (map doc-markup-function
  88                (sort markup-list-function-list markup-function<?)))
  89    "\n@end table"))
  90
  91 (define (markup-doc-node)
  92   (make <texi-node>
  93     #:name "Text markup commands"
  94     #:desc ""
  95     #:text "The following commands can all be used inside @code{\\markup @{ @}}."
  96     #:children (let* (;; when a new category is defined, update `ordered-categories'
  97                       (ordered-categories '(font align graphic music instrument-specific-markup other))
  98                       (raw-categories (hash-fold (lambda (category functions categories)
  99                                                    (cons category categories))
 100                                                  (list)
 101                                                  markup-functions-by-category))
 102                       (categories (append ordered-categories
 103                                           (filter (lambda (cat)
 104                                                     (not (memq cat ordered-categories)))
 105                                                   raw-categories))))
 106                  (map markup-category-doc-node categories))))
 107
 108 (define (markup-list-doc-node)
 109   (make <texi-node>
 110     #:name "Text markup list commands"
 111     #:desc ""
 112     #:text (string-append
 113             "The following commands can all be used with @code{\\markuplines}.\n"
 114             (markup-list-doc-string))))