LilyPond-Ruby 0.1.1 → 0.1.2

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

@@ -0,0 +1,307 @@
+;;;; 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/>.
+
+(define (sort-grob-properties props)
+  ;; force 'meta to the end of each prop-list
+  (let ((meta (assoc 'meta props)))
+    (append (sort (assoc-remove! props 'meta) ly:alist-ci<?)
+            (list meta))))
+
+;; properly sort all properties and interfaces
+;; within the all-grob-descriptions alist
+(set! all-grob-descriptions
+      (map!
+       (lambda (grob-description)
+         (let* ((grob-key      (car grob-description))
+                (props         (assoc-ref all-grob-descriptions grob-key))
+                (meta          (assoc-ref props 'meta))
+                (interfaces    (assoc-ref meta 'interfaces))
+                (sorted-ifaces (sort interfaces ly:symbol-ci<?))
+                (new-meta      (assoc-set! meta 'interfaces sorted-ifaces))
+                (new-props     (assoc-set! props 'meta new-meta))
+                (sorted-props  (sort-grob-properties new-props)))
+           (cons grob-key sorted-props)))
+       all-grob-descriptions))
+
+;; sort all grobs in the all-grob-descriptions alist
+(set! all-grob-descriptions (sort all-grob-descriptions ly:alist-ci<?))
+
+(define (interface-doc-string interface)
+  (let* ((name (car interface))
+         (desc (string-trim-both (cadr interface)))
+         (props (caddr interface))
+         (docfunc (lambda (pr)
+                    (property->texi 'backend pr)))
+         (iprops (filter (lambda (x) (object-property x 'backend-internal))
+                         props))
+         (uprops (filter
+                  (lambda (x) (not (object-property x 'backend-internal)))
+                  props))
+         (user-propdocs (map docfunc uprops))
+         (internal-propdocs (map docfunc iprops)))
+
+    (string-append
+     desc
+
+     (if (pair? uprops)
+         (string-append
+          "\n\n@subsubheading User settable properties:\n"
+          (description-list->texi user-propdocs #t))
+         "")
+
+     (if (pair? iprops)
+         (string-append
+          "\n\n@subsubheading Internal properties:\n"
+          (description-list->texi internal-propdocs #t))
+         ""))))
+
+;; The defining interface is expected to be first.
+(define class-specific-interfaces
+  '((Item . (item-interface))
+    (Spanner . (spanner-interface))
+    (Paper_column . (paper-column-interface item-interface))
+    (System . (system-interface spanner-interface))))
+
+
+;; Map interface to list of grobs that support it.
+(define iface->grob-table (make-hash-table 61))
+;; item-interface and spanner-interface (maybe others in
+;; the future) are supported "conditionally": a Footnote,
+;; for example, supports either of them depending on the
+;; object it annotates.  We distinguish this situation in
+;; the presentation.
+(define class-iface->conditional-grob-table (make-hash-table 4))
+(for-each
+ (lambda (grob-entry)
+   (let* ((grob-name (car grob-entry))
+          (grob-description (cdr grob-entry))
+          (meta (assoc-get 'meta grob-description))
+          (ifaces (assoc-get 'interfaces meta))
+          (classes (assoc-get 'classes meta))
+          (two-or-more (pair? (cdr classes)))
+          (class-table (if two-or-more
+                           class-iface->conditional-grob-table
+                           iface->grob-table)))
+
+     (for-each (lambda (iface)
+                 (hashq-set!
+                  iface->grob-table iface
+                  (cons grob-name
+                        (hashq-ref iface->grob-table iface '()))))
+               ifaces)
+     (for-each (lambda (class)
+                 (let ((class-ifaces
+                        (assoc-get class class-specific-interfaces)))
+                   (for-each
+                    (lambda (class-iface)
+                      (hashq-set!
+                       class-table
+                       class-iface
+                       (cons grob-name (hashq-ref class-table class-iface '()))))
+                    class-ifaces)))
+               classes)))
+ all-grob-descriptions)
+
+;; First level Interface description
+(define (interface-doc interface)
+  (let* ((name (car interface))
+         (unconditional-grobs (hashq-ref iface->grob-table name))
+         (conditional-grobs (hashq-ref class-iface->conditional-grob-table name)))
+    (make <texi-node>
+      #:code-tag #t
+      #:name (symbol->string name)
+      #:text (string-append
+              (interface-doc-string (cdr interface))
+              "\n\n@raggedRight\n"
+              "This grob interface "
+              (if unconditional-grobs
+                  (format #f
+                          "is used in the following graphical object(s): ~a."
+                          (list-xref-symbols unconditional-grobs))
+                  "is not used in any graphical object.")
+              "\n\n"
+              (if conditional-grobs
+                  (format #f
+                          "In addition, this interface is supported conditionally
+by the following objects depending on their class: ~a."
+                          (list-xref-symbols  conditional-grobs))
+                  "")
+              "\n@endRaggedRight"))))
+
+(define (grob-alist->texi alist)
+  (let* ((uprops (filter (lambda (x) (not (object-property x 'backend-internal)))
+                         (map car alist))))
+
+    (description-list->texi
+     (map (lambda (y) (property->texi 'backend y alist))
+          uprops)
+     #t)))
+
+(define (grob-doc description)
+  "Given a property alist DESCRIPTION, make a documentation
+node."
+
+  (let* ((meta (assoc-get 'meta description))
+         (name (assoc-get 'name meta))
+         (docstring (assoc-get 'description meta ""))
+         (ifaces (assoc-get 'interfaces meta))
+         (classes (assoc-get 'classes meta))
+         (class-interfaces (map (lambda (class)
+                                  (assoc-get class class-specific-interfaces))
+                                classes))
+         (two-or-more (pair? (cdr classes)))
+         (engravers (filter
+                     (lambda (x) (engraver-makes-grob? name x))
+                     all-engravers-list))
+         (namestr (symbol->string name))
+         (engraver-names (map ly:translator-name engravers)))
+
+    (make <texi-node>
+      #:code-tag #t
+      #:name namestr
+      #:text
+      (string-append
+       "\n\n"
+       docstring
+       "\n\n"
+       "@raggedRight\n"
+       "@code{"
+       namestr "} objects "
+       (cond
+        ((not (null? engraver-names))
+         (string-append
+          "are created by: "
+          (list-xref-symbols engraver-names)))
+        ((eq? name 'System)
+         "are created internally by the @code{Score_engraver} translator group.")
+        (else
+         (ly:error "no engraver declares that it creates ~a grobs" name)))
+
+       "."
+       "\n@endRaggedRight"
+
+       "\n\nStandard settings:\n"
+       (grob-alist->texi description)
+       "\n\n@raggedRight\n"
+       "This object supports the following interface(s):\n"
+       (list-xref-symbols
+        (if two-or-more
+            ifaces
+            (append ifaces (car class-interfaces))))
+       ".\n\n"
+       (if two-or-more
+           (format #f "This object can be of either of the following classes: ~a.
+It supports the following interfaces conditionally depending on the class: ~a."
+                   (human-listify
+                    (map
+                     (lambda (class ifaces)
+                       (format #f "~a (characterized by ~a)"
+                               class
+                               (human-listify (map symbol->string ifaces))))
+                     classes
+                     class-interfaces)
+                    #:last-word "or")
+                   ;; No sorting here, let's keep in same order as the
+                   ;; parenthesized "characterized by" indications.
+                   (list-xref-symbols
+                    (apply append class-interfaces)
+                    #:sorted #f))
+           (format #f "This object is of class ~a (characterized by ~a)."
+                   (car classes)
+                   (ref-ify (symbol->string (caar class-interfaces)))))
+       "\n\n@endRaggedRight"))))
+
+(define (all-grobs-doc)
+  (make <texi-node>
+    #:name "All layout objects"
+    #:desc "Description and defaults for all graphical objects (grobs)."
+    #:children
+    (map (lambda (x) (grob-doc (cdr x)))  all-grob-descriptions)))
+
+(define interface-description-alist
+  (hash-fold
+   (lambda (key val prior)
+     (cons (cons key val)  prior))
+   '() (ly:all-grob-interfaces)))
+
+;; sort user-settable and internal props within each grob-interface
+(set! interface-description-alist
+      (map! (lambda (iface-desc)
+              (let* ((key-name-docstr (list-head iface-desc 3))
+                     (props           (list-tail iface-desc 3))
+                     (sorted-props    (list (sort (car props) ly:symbol-ci<?))))
+                (append key-name-docstr sorted-props)))
+            interface-description-alist))
+
+;; sort list of grob interfaces
+(set! interface-description-alist
+      (sort interface-description-alist ly:alist-ci<?))
+
+;;;;;;;;;; check for dangling backend properties.
+(define (mark-interface-properties entry)
+  (for-each (lambda (x) (set-object-property! x 'iface-marked #t))
+            (caddr (cdr entry))))
+
+(for-each mark-interface-properties interface-description-alist)
+
+(define (check-dangling-properties prop)
+  (if (not (object-property prop 'iface-marked))
+      (ly:error (string-append "define-grob-properties.scm: "
+                               (G_ "cannot find interface for property: ~S")) prop)))
+
+(for-each check-dangling-properties all-backend-properties)
+
+;;;;;;;;;;;;;;;;
+
+(define (lookup-interface name)
+  (let* ((entry (hashq-ref (ly:all-grob-interfaces) name #f)))
+    (if entry
+        entry
+        (ly:error (G_ "unknown Grob interface: ~S") name))))
+
+(define (all-interfaces-doc)
+  (make <texi-node>
+    #:name "Graphical Object Interfaces"
+    #:desc "Building blocks of graphical objects."
+    #:children
+    (map interface-doc interface-description-alist)))
+
+(define (backend-properties-doc-string lst)
+  (let* ((ps (sort (map symbol->string lst) ly:string-ci<?))
+         (descs (map (lambda (prop)
+                       (property->texi 'backend (string->symbol prop) '())) ps))
+         (texi (description-list->texi descs #f)))
+    texi))
+
+;;(dump-node (grob-doc (cdadr all-grob-descriptions)) (current-output-port) 0 )
+(define (backend-doc-node)
+  (make <texi-node>
+    #:name "Backend"
+    #:desc "Reference for the layout engine."
+    #:children
+    (list
+     (all-grobs-doc)
+     (all-interfaces-doc)
+     (make <texi-node>
+       #:name "User backend properties"
+       #:desc "All tunable properties in a big list."
+       #:text (backend-properties-doc-string all-user-grob-properties))
+     (make <texi-node>
+       #:name "Internal backend properties"
+       #:desc "All internal layout properties in a big list."
+       #:text (backend-properties-doc-string all-internal-grob-properties)))))

data/share/lilypond/2.24.1/scm/lily/document-context-mods.scm

@@ -0,0 +1,98 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2011--2022 Neil Puttock <n.puttock@gmail.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/>.
+
+(use-modules (ice-9 format))
+
+(define (grob-property-path path)
+  (string-join (map symbol->string path) " "))
+
+(define (document-mod-list op)
+  (let ((tag (car op))
+        (name-sym (cadr op))
+        (args (cddr op)))
+    (case tag
+      ((push)
+       (let ((value (car args))
+             (path (cdr args)))
+         (string-append
+          (format #f "@item Sets grob property @code{~a} "
+                  (grob-property-path path))
+          (format #f "in @code{@rinternals{~a}} to" name-sym)
+          (if (pretty-printable? value)
+              (format #f ":~a\n" (scm->texi value))
+              (format #f " ~a.\n" (scm->texi value))))))
+      ((pop)
+       (string-append
+        (format #f "@item Reverts grob property @code{~a} "
+                (grob-property-path (car args)))
+        (format #f "in @code{@rinternals{~a}}.\n"
+                name-sym)))
+      ((assign)
+       (string-append
+        (format #f "@item Sets translator property @code{~a} to" name-sym)
+        (if (pretty-printable? (car args))
+            (format #f ":~a\n" (scm->texi (car args)))
+            (format #f " ~a.\n" (scm->texi (car args))))))
+      ((unset)
+       (format #f "@item Unsets translator property @code{~a}.\n"
+               name-sym))
+      ((consists)
+       (format #f "@item Adds @code{@rinternals{~a}}.\n" name-sym))
+      ((remove)
+       (format #f "@item Removes @code{@rinternals{~a}}.\n" name-sym))
+      (else ""))))
+
+(define (document-context-mod context-mod-pair)
+  (let* ((name-sym (car context-mod-pair))
+         (mod-list (ly:get-context-mods (cdr context-mod-pair)))
+         (docstring (filter (lambda (mod)
+                              (eq? (car mod) 'description))
+                            mod-list)))
+    (format #f
+            "@item @code{\\~a}
+@funindex \\~a
+~a
+@itemize
+~{~a ~}
+@end itemize
+"
+            name-sym
+            name-sym
+            (if (pair? docstring)
+                (cadar docstring)
+                (begin
+                  (ly:warning (G_ "context modification `~a' not documented.") name-sym)
+                  "(undocumented; fixme)"))
+            (map document-mod-list mod-list))))
+
+(define (document-mod obj-pair)
+  (and (ly:context-mod? (cdr obj-pair))
+       (document-context-mod obj-pair)))
+
+(define context-mods-doc-string
+  (format #f
+          "@table @asis
+~a
+@end table
+"
+          (string-join
+           (filter-map
+            document-mod
+            (sort
+             (ly:module->alist (current-module))
+             identifier<?)))
+          ""))

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

@@ -0,0 +1,169 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 1998--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)
+ (ice-9 regex)
+ (ice-9 session))
+
+(define (dashify-underscores str)
+  (regexp-substitute/global #f "_" str 'pre "-" 'post))
+
+(define (format-c-header c-h)
+  (regexp-substitute/global
+   #f ","
+   (regexp-substitute/global #f "(SCM|\\)|\\() *" (dashify-underscores c-h)
+                             'pre "" 'post)
+   'pre " " 'post))
+
+;; If there is `::` in the function name, insert a breakpoint to avoid
+;; overlong index entries that would otherwise stick out to the right
+;; in the two-column output of the PDF documentation.  Alas, this
+;; triggers a bug in `texi2html` 1.82; we thus have to temporarily
+;; enclose `prettier-name` with `@code` until an upgrade to a recent
+;; `texi2any` version.
+(define (document-function name arguments doc-string is-macro)
+  (let* ((cmd (if is-macro "defmac" "defun"))
+         (str-name (symbol->string name))
+         (prettier-name
+          (regexp-substitute/global #f "::" str-name 'pre "::@/" 'post)))
+    (format #f "@~a @code{~a} ~a\n~a\n@end ~a\n\n"
+            cmd prettier-name arguments doc-string cmd)))
+
+;; Map function names (as strings) to full documentation entries
+;; including signature and doc-string.
+(define all-primitive-function-docs-alist
+  (hash-map->list
+   (lambda (name header-doc-string-pair)
+     (cons (symbol->string name)
+           (document-function name
+                              (format-c-header (car header-doc-string-pair))
+                              (cdr header-doc-string-pair)
+                              #f)))
+   (ly:get-all-function-documentation)))
+
+(define (format-scheme-signature proc)
+  (let* ((signature (procedure-arguments proc))
+         (required-args (assq-ref signature 'required))
+         (optional-args (assq-ref signature 'optional))
+         (keyword-args (assq-ref signature 'keyword))
+         (rest-arg (assq-ref signature 'rest)))
+    ;; Example formatted signature:
+    ;; (define* (f arg1 arg2 #:optional opt1 opt2 #:key kw1 (kw2 default2) . rest)
+    ;;   ...)
+    ;; => f arg1 arg2 [opt1 [opt2]] #:kw1 kw1 #:kw2 kw2 rest ...
+    ;; It would be nicer to use [#:kw2=default2] when there is a default,
+    ;; but sadly, Guile doesn't seem to make it available (or Jean has not
+    ;; found it).  We don't even know whether the keyword argument has a
+    ;; default (and is thus optional) or not.
+    (string-join
+     (append
+      (map symbol->string required-args)
+      (match optional-args
+        (()
+         '())
+        ((opts ... last-opt)
+         (list
+          (fold-right
+           (lambda (next-arg args-so-far)
+             (format #f "[~a ~a]" next-arg args-so-far))
+           (format #f "[~a]" last-opt)
+           opts))))
+      (map (lambda (pair)
+             (let ((kw (car pair)))
+               (format #f "~a ~a"
+                       kw
+                       (keyword->symbol kw))))
+           keyword-args)
+      (if rest-arg
+          (list
+           (format #f "~a @dots{}" rest-arg))
+          '()))
+     " ")))
+
+
+;; Same format as all-primitive-function-docs-alist.
+(define all-scheme-function-docs-alist
+  (let* ((module (resolve-module '(lily)))
+         ;; Restrict to public functions.
+         (iface (module-public-interface module))
+         (alist (ly:module->alist iface)))
+    (filter-map
+     (lambda (entry)
+       (let* ((name (car entry))
+              (raw-value (cdr entry))
+              (is-macro (macro? raw-value))
+              (value (if is-macro
+                         (macro-transformer raw-value)
+                         raw-value)))
+         (if (and (procedure? value)
+                  ;; Exclude functions that are documented through the
+                  ;; C++ infrastructure (all-primitive-function-docs-alist
+                  ;; above).
+                  (not (hashq-get-handle (ly:get-all-function-documentation)
+                                         name))
+                  ;; Exclude xxx-markup functions, they are documented in NR.
+                  ;; Note that make-xxx-markup is excluded by the documentation
+                  ;; check (those don't have doc-strings).
+                  (not (or (markup-function? value)
+                           (markup-list-function? value))))
+             (let* ((doc-string (procedure-documentation value)))
+               ;; Many functions are publicly defined but do not need
+               ;; documentation, like all Scheme-defined callbacks,
+               ;; which are often self-telling and present in individual
+               ;; grobs' pages.  We only retain functions that have
+               ;; doc-strings.  If your pet function doesn't appear in
+               ;; the internals, please give it a doc-string!
+               (if doc-string
+                   (cons (symbol->string name)
+                         (document-function name
+                                            (if is-macro
+                                                ;; Guile doesn't give us meaningful
+                                                ;; signatures for macros.
+                                                "@dots{}"
+                                                (format-scheme-signature value))
+                                            doc-string
+                                            is-macro))
+                   #f))
+             #f)))
+     alist)))
+
+;; We want to sort without taking the ly: prefix into account.
+(define (no-ly-prefix-key name-doc-alist-entry)
+  (let* ((name (car name-doc-alist-entry)))
+    (if (string-startswith name "ly:")
+        (string-drop name 3)
+        name)))
+
+(define (all-functions-doc)
+  (let* ((all-function-doc-alists
+          (append
+           all-primitive-function-docs-alist
+           all-scheme-function-docs-alist))
+         (sorted-alist
+          (sort all-function-doc-alists
+                (comparator-from-key no-ly-prefix-key ly:string-ci<?)))
+         (formatted-docs
+          (map cdr sorted-alist)))
+    (make <texi-node>
+      #:name "Scheme functions"
+      #:desc "Functions exported by LilyPond."
+      #:text
+      (string-concatenate formatted-docs))))
+
+;; (dump-node (all-functions-doc)  (current-output-port) 0 )

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

@@ -0,0 +1,76 @@
+;;;; This file is part of LilyPond, the GNU music typesetter.
+;;;;
+;;;; Copyright (C) 2006--2022 Han-Wen Nienhuys <hanwen@lilypond.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 format))
+
+(define (document-music-function music-func-pair)
+  (let*
+      ((name-sym (car music-func-pair))
+       (music-func (cdr music-func-pair))
+       (func (ly:music-function-extract music-func))
+       (full-doc (procedure-documentation func))
+       (match-args (and full-doc (string-match "^\\([^)]*\\)\n" full-doc)))
+       (arg-names (if match-args
+                      (with-input-from-string (match:string match-args) read)
+                      (circular-list "arg")))
+       (doc (if match-args (match:suffix match-args) full-doc))
+       (sign (ly:music-function-signature music-func))
+       (type-names (map (lambda (pred)
+                          (if (pair? pred)
+                              (format #f "[~a]" (type-name (car pred)))
+                              (format #f "(~a)" (type-name pred))))
+                        sign))
+       (signature-str
+        (string-join
+         (map (lambda (arg type) (format #f "@var{~a} ~a" arg type))
+              arg-names (cdr type-names)))))
+    (format #f
+            "@item @code{~a~a} ~a ~a~a
+@funindex ~a~a
+~a
+"
+            (if (eq? (string-ref (symbol->string name-sym) 0) #\\) "" "\\")
+            name-sym
+            (car type-names)
+            (if (string-null? signature-str) "" " - ")
+            signature-str
+            (if (eq? (string-ref (symbol->string name-sym) 0) #\\) "" "\\")
+            name-sym
+            (if (and doc (not (string-null? doc)))
+                doc
+                (begin
+                  (ly:warning (G_ "music function `~a' not documented.") name-sym)
+                  "(undocumented; fixme)")))))
+
+
+(define (document-object obj-pair)
+  (and (ly:music-function? (cdr obj-pair))
+       (document-music-function obj-pair)))
+
+(define-public (identifiers-doc-string)
+  (format #f
+          "@table @asis
+~a
+@end table
+"
+          (string-join
+           (filter-map
+            document-object
+            (sort
+             (ly:module->alist (current-module))
+             identifier<?)))
+          ""))