Issue 2872: Provide define-session and define-session-public commands

Also moves the session logic into lily.scm instead of init.ly

A session corresponds to one .ly file on the LilyPond command line;
sessions are supposed to be processed independently in one LilyPond
run.

define-session will declare a variable that has its value recorded at
the start of the first session and reinstated at the start of each
following sessions.  This is automatically the case for every variable
defined in variables in the parser module established while loading
ly/declarations-init.ly.  However, not every changeable information
handled in the .scm parts of LilyPond can easily or reasonably be
stored in the parser module.  define-session (and
define-session-public) provide a way to get the same semantics for
variables defined in the Scheme parts of LilyPond.

diff --git a/ly/init.ly b/ly/init.ly
index a8bcc65d1143daa0a9904b2f7d3f71f02154731f..7daa84929c6e578d423e4a2d353cb387874cc56d 100644 (file)
--- a/ly/init.ly
+++ b/ly/init.ly
@@ -6,43 +6,18 @@
 
 \version "2.16.0"
 
-#(if (not (ly:undead? lilypond-declarations))
-     (ly:parser-include-string parser
-                              "\\include \"declarations-init.ly\""))
+#(session-initialize
+  (lambda ()
+   ;; we can't use ly:parser-include-string here since that does not
+   ;; actually do any parsing but merely switches inputs, so the
+   ;; session saved by the session initializer after calling this
+   ;; function has not actually started.  A parser clone, in contrast,
+   ;; can run and complete synchronously and shares the module with
+   ;; the current parser.
+   (ly:parser-parse-string (ly:parser-clone parser)
+    "\\include \"declarations-init.ly\"")))
 
-%% We need to save the variables of the current module along with
-%% their values: functions defined in the module might refer to the
-%% variables
-
-#(if lilypond-declarations
-     (if (ly:undead? lilypond-declarations)
-        (begin
-          (for-each
-           (lambda (p)
-             (let ((var (cadr p))
-                   (val (cddr p)))
-               (variable-set! var
-                              (if (ly:output-def? val)
-                                  (ly:output-def-clone val)
-                                  val))
-               (module-add! (current-module) (car p) var)))
-           (ly:get-undead lilypond-declarations))
-          (note-names-language parser default-language))
-        (let ((decl '()))
-          (module-for-each
-           (lambda (s v)
-             (let ((val (variable-ref v)))
-               (if (not (ly:lily-parser? val))
-                   (set! decl
-                         (cons
-                          (cons*
-                           s v
-                           (if (ly:output-def? val)
-                               (ly:output-def-clone val)
-                               val))
-                          decl)))))
-           (current-module))
-          (set! lilypond-declarations (ly:make-undead decl)))))
+#(note-names-language parser default-language)
 
 #(ly:set-option 'old-relative #f)
 #(define toplevel-scores (list))

diff --git a/scm/lily.scm b/scm/lily.scm
index 3ee924a1b1c44c429e635156416d8789af7a74de..b8b0216467e835926d216eaf4531bb92a21f6fde 100644 (file)
--- a/scm/lily.scm
+++ b/scm/lily.scm
@@ -43,6 +43,77 @@
    (string-downcase
     (car (string-tokenize (utsname:sysname (uname)))))))
 
+(define lilypond-declarations '())
+
+(defmacro-public define-session (name value)
+  "This defines a variable @var{name} with the starting value
+@var{value} that is reinitialized at the start of each session.
+A@tie{}session basically corresponds to one LilyPond file on the
+command line.  The value is recorded at the start of the first session
+after loading all initialization files and before loading the user
+file and is reinstated for all of the following sessions.  This
+happens just by replacing the value, not by copying structures, so you
+should not destructively modify them.  For example, lists defined in
+this manner should be changed within a session only be adding material
+to their front or replacing them altogether, not by modifying parts of
+them.  It is an error to call @code{define-session} after the first
+session has started."
+  (define (add-session-variable name value)
+    (if (ly:undead? lilypond-declarations)
+        (ly:error (_ "define-session used after session start")))
+    (let ((var (make-variable value)))
+      (module-add! (current-module) name var)
+      (set! lilypond-declarations (cons var lilypond-declarations))))
+  `(,add-session-variable ',name ,value))
+
+(defmacro-public define-session-public (name value)
+  "Like @code{define-session}, but also exports @var{name}."
+  `(begin
+     (define-session ,name ,value)
+     (export ,name)))
+
+(define-public (session-initialize thunk)
+  "Initialize this session.  The first session in a LilyPond run is
+initialized by calling @var{thunk}, then recording the values of all
+variables in the current module as well as those defined with
+@code{define-session}.  Subsequent calls of @code{session-initialize}
+ignore @var{thunk} and instead just reinitialize all recorded
+variables to their value after the initial call of @var{thunk}."
+
+;; We need to save the variables of the current module along with
+;; their values: functions defined in the module might refer to the
+;; variables.
+
+;; The entries in lilypond-declarations consist of a cons* consisting
+;; of symbol, variable, and value.  Variables defined with
+;; define-session have the symbol set to #f.
+
+  (if (ly:undead? lilypond-declarations)
+      (begin
+        (for-each
+         (lambda (p)
+           (let ((var (cadr p))
+                 (val (cddr p)))
+             (variable-set! var val)
+             (if (car p)
+                 (module-add! (current-module) (car p) var))))
+         (ly:get-undead lilypond-declarations)))
+      (begin
+        (thunk)
+        (let ((decl (map! (lambda (v)
+                            (cons* #f v (variable-ref v)))
+                          lilypond-declarations)))
+          (module-for-each
+           (lambda (s v)
+             (let ((val (variable-ref v)))
+               (if (not (ly:lily-parser? val))
+                   (set! decl
+                         (cons
+                          (cons* s v val)
+                          decl)))))
+           (current-module))
+          (set! lilypond-declarations (ly:make-undead decl))))))
+
 (define scheme-options-definitions
   `(
     ;; NAMING: either
@@ -865,8 +936,6 @@ PIDs or the number of the process."
         (dump-profile "lily-run-total" '(0 0) (profile-measurements)))
     failed))
 
-(define-public lilypond-declarations '())
-
 (define (lilypond-file handler file-name)
   (catch 'ly-file-failed
          (lambda () (ly:parse-file file-name))