added node-addon-lilypond

node-addon-lilypond/output/extra/libc.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:467d8d5596e31cec78cdcde0c589bd04c031ec36598531bfd77e346ac447d9d6
+size 2030928

node-addon-lilypond/output/extra/libdl.so.2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:398f33bacb604813ef22a5ae10b73a319180a6467a5e3e60a412dd271b2aff3b
+size 14560

node-addon-lilypond/output/extra/libexpat.so.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f15cdbce5b1b9a0032fe1ab4e17eea95601dd8a6404ba20c98a7103e3089676e
+size 202880

node-addon-lilypond/output/extra/libgcc_s.so.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f0e486606bd477c6a6ad3588176a16099ed05a8bf47cf3bd27b490bea3d59e9
+size 96616

node-addon-lilypond/output/extra/libgmp.so.10

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d54e955d21688b5b840ac49dda592be5e1f5546df67eb18fea400116e76b9852
+size 526688

node-addon-lilypond/output/extra/libm.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:464dcab115cca26b8715cf3521f9ca1d9b7eb6b0500b7d3bed7a2353fd744c52
+size 1700792

node-addon-lilypond/output/extra/libpcre.so.3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d14920b8c1cb4e4cbe5f7c9ad23f6d9cf7b4ab1ddce1a29c9fc766b51c29ebea
+size 464824

node-addon-lilypond/output/extra/libpthread.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:99c0999f13790d4365986180bc2e6dccbabd4d9b874a76799014c0c397e8f02a
+size 144976

node-addon-lilypond/output/extra/libstdc++.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7ce5e3ab89895f02ad5d55f6b2090c3882ba5f4e12fbd9b96f0ed1712e2a1f6
+size 1594864

node-addon-lilypond/output/extra/libz.so.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:219c6c0efe93bd6d751bba1e8ae84a162309c665cc5e36beddcf295b72f9bc09
+size 116960

node-addon-lilypond/output/libdatrie.so.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c30fb636f01c4bbce7a5ac3eadcba61720d0821a2cbaa5238a675b7370caaad
+size 26544

node-addon-lilypond/output/libffi.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a675e4f4e40312eebbaf9816e009793a394ae9385115bf10b82b83643f84963
+size 31032

node-addon-lilypond/output/libfontconfig.so.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7a8a2c7373cd9483fa9af3e797a33144979de9125d578bb6b63e47f56e4f58de
+size 281984

node-addon-lilypond/output/libfreetype.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2e48e02376decc11d1b8cf5b09c8e0f991d31d8909d0fd2c006dc2b1209e860
+size 735704

node-addon-lilypond/output/libglib-2.0.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9450de63b8dfe0e3dfc753d77c8cf86531365efeccee68578dd6b08ad9a68779
+size 1137968

node-addon-lilypond/output/libgobject-2.0.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:677342b9e18f64c658d7b8133ecc8c5654cbca07484fdceabdbd2331e18e4cd8
+size 342072

node-addon-lilypond/output/libgraphite2.so.3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5efccb06571c46f4aef27805688f4dc5e168d1224edea3fc61b339f2a33aa348
+size 182424

node-addon-lilypond/output/libguile-srfi-srfi-1-v-3.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfb0db9ad891809b90ed161022eb340959d93ec701b2c88b1aa437fe4f284b74
+size 108192

node-addon-lilypond/output/libguile.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6722c0302a80aa446436ad49fdc0678ebd0782ed92ddea70ebf9e0e902ebebf3
+size 1235424

node-addon-lilypond/output/libharfbuzz.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ed819725042eb62aed9c0e257ad35e9d6834912a8ceafccd5333005567cac0a
+size 646064

node-addon-lilypond/output/liblilypond.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25cfa4b0972c0dbaa66e71b5a652479e3a67a3611cf518614317a8819f075711
+size 8707312

node-addon-lilypond/output/libpango-1.0.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d0bb21da459593889d1f60319779d35840915620d0f96c385c4711a32199e26a
+size 313264

node-addon-lilypond/output/libpangoft2-1.0.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2663e090308fd304b0931775da8c4664f8871ddc4392937178e2e996818b36f8
+size 87904

node-addon-lilypond/output/libpng16.so.16

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0353da90d7c3699685c99c2cabf17d7b4a4212c3a2d6c29beb739e1c83da418e
+size 202672

node-addon-lilypond/output/libthai.so.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39373a82e85412d5a6ed68d2ff3e37da5452895894844eb8523eca5f3c687092
+size 36904

node-addon-lilypond/output/lilypond.node

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:980e421accd2cc159019be6c9cfe0a32d77b2eb7fd702070f3910f9c3cc4ff54
+size 305080

node-addon-lilypond/output/share/guile/1.8/ice-9/and-let-star.scm

@@ -0,0 +1,49 @@
+;;;; and-let-star.scm --- and-let* syntactic form (draft SRFI-2) for Guile
+;;;; written by Michael Livshin <mike@olan.com>
+;;;;
+;;;; 	Copyright (C) 1999, 2001, 2004, 2006 Free Software Foundation, Inc.
+;;;; 
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 and-let-star)
+  :export-syntax (and-let*))
+
+(defmacro and-let* (vars . body)
+
+  (define (expand vars body)
+    (cond
+     ((null? vars)
+      (if (null? body)
+	  #t
+	  `(begin ,@body)))
+     ((pair? vars)
+      (let ((exp (car vars)))
+        (cond
+         ((pair? exp)
+          (cond
+           ((null? (cdr exp))
+            `(and ,(car exp) ,(expand (cdr vars) body)))
+           (else
+            (let ((var (car exp)))
+              `(let (,exp)
+                 (and ,var ,(expand (cdr vars) body)))))))
+         (else
+          `(and ,exp ,(expand (cdr vars) body))))))
+     (else
+      (error "not a proper list" vars))))
+
+  (expand vars body))
+
+(cond-expand-provide (current-module) '(srfi-2))

node-addon-lilypond/output/share/guile/1.8/ice-9/buffered-input.scm

@@ -0,0 +1,112 @@
+;;;; buffered-input.scm --- construct a port from a buffered input reader
+;;;;
+;;;; 	Copyright (C) 2001, 2006 Free Software Foundation, Inc.
+;;;; 
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 buffered-input)
+  #:export (make-buffered-input-port
+            make-line-buffered-input-port
+            set-buffered-input-continuation?!))
+
+;; @code{buffered-input-continuation?} is a property of the ports
+;; created by @code{make-line-buffered-input-port} that stores the
+;; read continuation flag for each such port.
+(define buffered-input-continuation? (make-object-property))
+
+(define (set-buffered-input-continuation?! port val)
+  "Set the read continuation flag for @var{port} to @var{val}.
+
+See @code{make-buffered-input-port} for the meaning and use of this
+flag."
+  (set! (buffered-input-continuation? port) val))
+
+(define (make-buffered-input-port reader)
+  "Construct a line-buffered input port from the specified @var{reader}.
+@var{reader} should be a procedure of one argument that somehow reads
+a chunk of input and returns it as a string.
+
+The port created by @code{make-buffered-input-port} does @emph{not}
+interpolate any additional characters between the strings returned by
+@var{reader}.
+
+@var{reader} should take a boolean @var{continuation?} argument.
+@var{continuation?} indicates whether @var{reader} is being called to
+start a logically new read operation (in which case
+@var{continuation?} is @code{#f}) or to continue a read operation for
+which some input has already been read (in which case
+@var{continuation?} is @code{#t}).  Some @var{reader} implementations
+use the @var{continuation?} argument to determine what prompt to
+display to the user.
+
+The new/continuation distinction is largely an application-level
+concept: @code{set-buffered-input-continuation?!} allows an
+application to specify when a read operation is considered to be new.
+But note that if there is non-whitespace data already buffered in the
+port when a new read operation starts, this data will be read before
+the first call to @var{reader}, and so @var{reader} will be called
+with @var{continuation?} set to @code{#t}."
+  (let ((read-string "")
+	(string-index -1))
+    (letrec ((get-character
+	      (lambda ()
+		(cond 
+		 ((eof-object? read-string)
+		  read-string)
+		 ((>= string-index (string-length read-string))
+		  (set! string-index -1)
+                  (get-character))
+		 ((= string-index -1)
+		  (set! read-string (reader (buffered-input-continuation? port)))
+                  (set! string-index 0)
+                  (if (not (eof-object? read-string))
+                      (get-character)
+                      read-string))
+		 (else
+		  (let ((res (string-ref read-string string-index)))
+		    (set! string-index (+ 1 string-index))
+                    (if (not (char-whitespace? res))
+                        (set! (buffered-input-continuation? port) #t))
+		    res)))))
+	     (input-waiting
+	      (lambda ()
+		(if (eof-object? read-string)
+		    1
+		    (- (string-length read-string) string-index))))
+             (port #f))
+      (set! port (make-soft-port (vector #f #f #f get-character #f input-waiting) "r"))
+      (set! (buffered-input-continuation? port) #f)
+      port)))
+
+(define (make-line-buffered-input-port reader)
+  "Construct a line-buffered input port from the specified @var{reader}.
+@var{reader} should be a procedure of one argument that somehow reads
+a line of input and returns it as a string @emph{without} the
+terminating newline character.
+
+The port created by @code{make-line-buffered-input-port} automatically
+interpolates a newline character after each string returned by
+@var{reader}.
+
+@var{reader} should take a boolean @var{continuation?} argument.  For
+the meaning and use of this argument, see
+@code{make-buffered-input-port}."
+  (make-buffered-input-port (lambda (continuation?)
+                              (let ((str (reader continuation?)))
+                                (if (eof-object? str)
+                                    str
+                                    (string-append str "\n"))))))
+
+;;; buffered-input.scm ends here

node-addon-lilypond/output/share/guile/1.8/ice-9/calling.scm

@@ -0,0 +1,326 @@
+;;;; calling.scm --- Calling Conventions
+;;;;
+;;;; 	Copyright (C) 1995, 1996, 1997, 2000, 2001, 2006 Free Software Foundation, Inc.
+;;;; 
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;; 
+
+(define-module (ice-9 calling)
+  :export-syntax (with-excursion-function
+		  with-getter-and-setter
+		  with-getter
+		  with-delegating-getter-and-setter
+		  with-excursion-getter-and-setter
+		  with-configuration-getter-and-setter
+		  with-delegating-configuration-getter-and-setter
+		  let-with-configuration-getter-and-setter))
+
+;;;;
+;;;
+;;; This file contains a number of macros that support 
+;;; common calling conventions.
+
+;;;
+;;; with-excursion-function <vars> proc
+;;;  <vars> is an unevaluated list of names that are bound in the caller.
+;;;  proc is a procedure, called:
+;;;	     (proc excursion)
+;;;
+;;;  excursion is a procedure isolates all changes to <vars>
+;;;  in the dynamic scope of the call to proc.  In other words,
+;;;  the values of <vars> are saved when proc is entered, and when
+;;;  proc returns, those values are restored.   Values are also restored
+;;;  entering and leaving the call to proc non-locally, such as using
+;;;  call-with-current-continuation, error, or throw.
+;;;
+(defmacro with-excursion-function (vars proc)
+  `(,proc ,(excursion-function-syntax vars)))
+
+
+
+;;; with-getter-and-setter <vars> proc
+;;;  <vars> is an unevaluated list of names that are bound in the caller.
+;;;  proc is a procedure, called:
+;;;	(proc getter setter)
+;;; 
+;;;  getter and setter are procedures used to access
+;;;  or modify <vars>.
+;;; 
+;;;  setter, called with keywords arguments, modifies the named
+;;;  values.   If "foo" and "bar" are among <vars>, then:
+;;; 
+;;;	(setter :foo 1 :bar 2)
+;;;	== (set! foo 1 bar 2)
+;;; 
+;;;  getter, called with just keywords, returns
+;;;  a list of the corresponding values.  For example,
+;;;  if "foo" and "bar" are among the <vars>, then
+;;; 
+;;;	(getter :foo :bar)
+;;;	=> (<value-of-foo> <value-of-bar>)
+;;; 
+;;;  getter, called with no arguments, returns a list of all accepted 
+;;;  keywords and the corresponding values.  If "foo" and "bar" are
+;;;  the *only* <vars>, then:
+;;; 
+;;;	(getter)
+;;;	=> (:foo <value-of-bar> :bar <value-of-foo>)
+;;; 
+;;;  The unusual calling sequence of a getter supports too handy
+;;;  idioms:
+;;; 
+;;;	(apply setter (getter))		;; save and restore
+;;; 
+;;;	(apply-to-args (getter :foo :bar)		;; fetch and bind
+;;;		    (lambda (foo bar) ....))
+;;; 
+;;;     ;; [ "apply-to-args" is just like two-argument "apply" except that it 
+;;;	;;   takes its arguments in a different order.
+;;; 
+;;;
+(defmacro with-getter-and-setter (vars proc)
+  `(,proc ,@ (getter-and-setter-syntax vars)))
+
+;;; with-getter vars proc
+;;;   A short-hand for a call to with-getter-and-setter.
+;;;   The procedure is called:
+;;;		(proc getter)
+;;;
+(defmacro with-getter (vars proc)
+  `(,proc ,(car (getter-and-setter-syntax vars))))
+
+
+;;; with-delegating-getter-and-setter <vars> get-delegate set-delegate proc
+;;;   Compose getters and setters.
+;;; 
+;;;   <vars> is an unevaluated list of names that are bound in the caller.
+;;;   
+;;;   get-delegate is called by the new getter to extend the set of 
+;;;	gettable variables beyond just <vars>
+;;;   set-delegate is called by the new setter to extend the set of 
+;;;	gettable variables beyond just <vars>
+;;;
+;;;   proc is a procedure that is called
+;;;		(proc getter setter)
+;;;
+(defmacro with-delegating-getter-and-setter (vars get-delegate set-delegate proc)
+  `(,proc ,@ (delegating-getter-and-setter-syntax vars get-delegate set-delegate)))
+
+
+;;; with-excursion-getter-and-setter <vars> proc
+;;;   <vars> is an unevaluated list of names that are bound in the caller.
+;;;   proc is called:
+;;;
+;;;		(proc excursion getter setter)
+;;;
+;;;   See also:
+;;;	with-getter-and-setter
+;;;	with-excursion-function
+;;;
+(defmacro with-excursion-getter-and-setter (vars proc)
+  `(,proc  ,(excursion-function-syntax vars)
+	  ,@ (getter-and-setter-syntax vars)))
+
+
+(define (excursion-function-syntax vars)
+  (let ((saved-value-names (map gensym vars))
+	(tmp-var-name (gensym "temp"))
+	(swap-fn-name (gensym "swap"))
+	(thunk-name (gensym "thunk")))
+    `(lambda (,thunk-name)
+       (letrec ((,tmp-var-name #f)
+		(,swap-fn-name
+		 (lambda () ,@ (map (lambda (n sn) 
+				      `(begin (set! ,tmp-var-name ,n)
+					      (set! ,n ,sn)
+					      (set! ,sn ,tmp-var-name)))
+				    vars saved-value-names)))
+		,@ (map (lambda (sn n) `(,sn ,n)) saved-value-names vars))
+	 (dynamic-wind
+	  ,swap-fn-name
+	  ,thunk-name
+	  ,swap-fn-name)))))
+
+
+(define (getter-and-setter-syntax vars)
+  (let ((args-name (gensym "args"))
+	(an-arg-name (gensym "an-arg"))
+	(new-val-name (gensym "new-value"))
+	(loop-name (gensym "loop"))
+	(kws (map symbol->keyword vars)))
+    (list `(lambda ,args-name
+	     (let ,loop-name ((,args-name ,args-name))
+		  (if (null? ,args-name)
+		      ,(if (null? kws)
+			   ''()
+			   `(let ((all-vals (,loop-name ',kws)))
+			      (let ,loop-name ((vals all-vals)
+					       (kws ',kws))
+				   (if (null? vals)
+				       '()
+				       `(,(car kws) ,(car vals) ,@(,loop-name (cdr vals) (cdr kws)))))))
+		      (map (lambda (,an-arg-name)
+			     (case ,an-arg-name
+			       ,@ (append
+				   (map (lambda (kw v) `((,kw) ,v)) kws vars)
+				   `((else (throw 'bad-get-option ,an-arg-name))))))
+			   ,args-name))))
+
+	  `(lambda ,args-name
+	     (let ,loop-name ((,args-name ,args-name))
+		  (or (null? ,args-name)
+		      (null? (cdr ,args-name))
+		      (let ((,an-arg-name (car ,args-name))
+			    (,new-val-name (cadr ,args-name)))
+			(case ,an-arg-name
+			  ,@ (append
+			      (map (lambda (kw v) `((,kw) (set! ,v ,new-val-name))) kws vars)
+			      `((else (throw 'bad-set-option ,an-arg-name)))))
+			(,loop-name (cddr ,args-name)))))))))
+
+(define (delegating-getter-and-setter-syntax  vars get-delegate set-delegate)
+  (let ((args-name (gensym "args"))
+	(an-arg-name (gensym "an-arg"))
+	(new-val-name (gensym "new-value"))
+	(loop-name (gensym "loop"))
+	(kws (map symbol->keyword vars)))
+    (list `(lambda ,args-name
+	     (let ,loop-name ((,args-name ,args-name))
+		  (if (null? ,args-name)
+		      (append!
+		       ,(if (null? kws)
+			    ''()
+			    `(let ((all-vals (,loop-name ',kws)))
+			       (let ,loop-name ((vals all-vals)
+						(kws ',kws))
+				    (if (null? vals)
+					'()
+					`(,(car kws) ,(car vals) ,@(,loop-name (cdr vals) (cdr kws)))))))
+		       (,get-delegate))
+		      (map (lambda (,an-arg-name)
+			     (case ,an-arg-name
+			       ,@ (append
+				   (map (lambda (kw v) `((,kw) ,v)) kws vars)
+				   `((else (car (,get-delegate ,an-arg-name)))))))
+			   ,args-name))))
+
+	  `(lambda ,args-name
+	     (let ,loop-name ((,args-name ,args-name))
+		  (or (null? ,args-name)
+		      (null? (cdr ,args-name))
+		      (let ((,an-arg-name (car ,args-name))
+			    (,new-val-name (cadr ,args-name)))
+			(case ,an-arg-name
+			  ,@ (append
+			      (map (lambda (kw v) `((,kw) (set! ,v ,new-val-name))) kws vars)
+			      `((else  (,set-delegate ,an-arg-name ,new-val-name)))))
+			(,loop-name (cddr ,args-name)))))))))
+
+
+
+
+;;; with-configuration-getter-and-setter <vars-etc> proc
+;;;
+;;;  Create a getter and setter that can trigger arbitrary computation.
+;;;
+;;;  <vars-etc> is a list of variable specifiers, explained below.
+;;;  proc is called:
+;;;
+;;;		(proc getter setter)
+;;;
+;;;   Each element of the <vars-etc> list is of the form:
+;;;
+;;;	(<var> getter-hook setter-hook)
+;;;
+;;;   Both hook elements are evaluated; the variable name is not.
+;;;   Either hook may be #f or procedure.
+;;;
+;;;   A getter hook is a thunk that returns a value for the corresponding
+;;;   variable.   If omitted (#f is passed), the binding of <var> is
+;;;   returned.
+;;;
+;;;   A setter hook is a procedure of one argument that accepts a new value
+;;;   for the corresponding variable.  If omitted, the binding of <var>
+;;;   is simply set using set!.
+;;;
+(defmacro with-configuration-getter-and-setter (vars-etc proc)
+  `((lambda (simpler-get simpler-set body-proc)
+      (with-delegating-getter-and-setter ()
+	simpler-get simpler-set body-proc))
+
+    (lambda (kw)
+      (case kw
+	,@(map (lambda (v) `((,(symbol->keyword (car v)))
+			     ,(cond
+			       ((cadr v)	=> list)
+			       (else		`(list ,(car v))))))
+	       vars-etc)))
+
+    (lambda (kw new-val)
+      (case kw
+	,@(map (lambda (v) `((,(symbol->keyword (car v)))
+			     ,(cond
+			       ((caddr v)	=> (lambda (proc) `(,proc new-val)))
+			       (else		`(set! ,(car v) new-val)))))
+	       vars-etc)))
+
+       ,proc))
+
+(defmacro with-delegating-configuration-getter-and-setter (vars-etc delegate-get delegate-set proc)
+  `((lambda (simpler-get simpler-set body-proc)
+      (with-delegating-getter-and-setter ()
+	simpler-get simpler-set body-proc))
+
+    (lambda (kw)
+      (case kw
+	,@(append! (map (lambda (v) `((,(symbol->keyword (car v)))
+				      ,(cond
+					((cadr v)	=> list)
+					(else		`(list ,(car v))))))
+			vars-etc)
+		   `((else (,delegate-get kw))))))
+
+    (lambda (kw new-val)
+      (case kw
+	,@(append! (map (lambda (v) `((,(symbol->keyword (car v)))
+				      ,(cond
+					((caddr v)	=> (lambda (proc) `(,proc new-val)))
+					(else		`(set! ,(car v) new-val)))))
+			vars-etc)
+		   `((else (,delegate-set kw new-val))))))
+
+    ,proc))
+
+
+;;; let-configuration-getter-and-setter <vars-etc> proc
+;;;
+;;;   This procedure is like with-configuration-getter-and-setter (q.v.)
+;;;   except that each element of <vars-etc> is:
+;;;
+;;;		(<var> initial-value getter-hook setter-hook)
+;;;
+;;;   Unlike with-configuration-getter-and-setter, let-configuration-getter-and-setter
+;;;   introduces bindings for the variables named in <vars-etc>.
+;;;   It is short-hand for:
+;;;
+;;;		(let ((<var1> initial-value-1)
+;;;		      (<var2> initial-value-2)
+;;;			...)
+;;;		  (with-configuration-getter-and-setter ((<var1> v1-get v1-set) ...) proc))
+;;;
+(defmacro let-with-configuration-getter-and-setter (vars-etc proc)
+  `(let ,(map (lambda (v) `(,(car v) ,(cadr v))) vars-etc)
+     (with-configuration-getter-and-setter ,(map (lambda (v) `(,(car v) ,(caddr v) ,(cadddr v))) vars-etc)
+					   ,proc)))

node-addon-lilypond/output/share/guile/1.8/ice-9/channel.scm

@@ -0,0 +1,170 @@
+;;; Guile object channel
+
+;; Copyright (C) 2001, 2006 Free Software Foundation, Inc.
+
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+;;; Commentary:
+
+;; Now you can use Guile's modules in Emacs Lisp like this:
+;;
+;;   (guile-import current-module)
+;;   (guile-import module-ref)
+;;
+;;   (setq assq (module-ref (current-module) 'assq))
+;;     => ("<guile>" %%1%% . "#<primitive-procedure assq>")
+;;
+;;   (guile-use-modules (ice-9 documentation))
+;;
+;;   (object-documentation assq)
+;;     =>
+;;  " - primitive: assq key alist
+;;    - primitive: assv key alist
+;;    - primitive: assoc key alist
+;;        Fetches the entry in ALIST that is associated with KEY.  To decide
+;;        whether the argument KEY matches a particular entry in ALIST,
+;;        `assq' compares keys with `eq?', `assv' uses `eqv?' and `assoc'
+;;        uses `equal?'.  If KEY cannot be found in ALIST (according to
+;;        whichever equality predicate is in use), then `#f' is returned.
+;;        These functions return the entire alist entry found (i.e. both the
+;;        key and the value)."
+;;
+;; Probably we can use GTK in Emacs Lisp.  Can anybody try it?
+;;
+;; I have also implemented Guile Scheme mode and Scheme Interaction mode.
+;; Just put the following lines in your ~/.emacs:
+;;
+;;   (require 'guile-scheme)
+;;   (setq initial-major-mode 'scheme-interaction-mode)
+;;
+;; Currently, the following commands are available:
+;;
+;;   M-TAB    guile-scheme-complete-symbol
+;;   M-C-x    guile-scheme-eval-define
+;;   C-x C-e  guile-scheme-eval-last-sexp
+;;   C-c C-b  guile-scheme-eval-buffer
+;;   C-c C-r  guile-scheme-eval-region
+;;   C-c :    guile-scheme-eval-expression
+;;
+;; I'll write more commands soon, or if you want to hack, please take
+;; a look at the following files:
+;;
+;;   guile-core/ice-9/channel.scm       ;; object channel
+;;   guile-core/emacs/guile.el          ;; object adapter
+;;   guile-core/emacs/guile-emacs.scm   ;; Guile <-> Emacs channels
+;;   guile-core/emacs/guile-scheme.el   ;; Guile Scheme mode
+;;
+;; As always, there are more than one bugs ;)
+
+;;; Code:
+
+(define-module (ice-9 channel)
+  :export (make-object-channel
+	   channel-open
+	   channel-print-value
+	   channel-print-token))
+
+;;;
+;;; Channel type
+;;;
+
+(define channel-type
+  (make-record-type 'channel '(stdin stdout printer token-module)))
+
+(define make-channel (record-constructor channel-type))
+
+(define (make-object-channel printer)
+  (make-channel (current-input-port)
+		(current-output-port)
+		printer
+		(make-module)))
+
+(define channel-stdin (record-accessor channel-type 'stdin))
+(define channel-stdout (record-accessor channel-type 'stdout))
+(define channel-printer (record-accessor channel-type 'printer))
+(define channel-token-module (record-accessor channel-type 'token-module))
+
+;;;
+;;; Channel
+;;;
+
+(define (channel-open ch)
+  (let ((stdin (channel-stdin ch))
+	(stdout (channel-stdout ch))
+	(printer (channel-printer ch))
+	(token-module (channel-token-module ch)))
+    (let loop ()
+      (catch #t
+	(lambda ()
+	  (channel:prompt stdout)
+	  (let ((cmd (read stdin)))
+	    (if (eof-object? cmd)
+	      (throw 'quit)
+	      (case cmd
+		((eval)
+		 (module-use! (current-module) token-module)
+		 (printer ch (eval (read stdin) (current-module))))
+		((destroy)
+		 (let ((token (read stdin)))
+		   (if (module-defined? token-module token)
+		     (module-remove! token-module token)
+		     (channel:error stdout "Invalid token: ~S" token))))
+		((quit)
+		 (throw 'quit))
+		(else
+		 (channel:error stdout "Unknown command: ~S" cmd)))))
+	  (loop))
+	(lambda (key . args)
+	  (case key
+	    ((quit) (throw 'quit))
+	    (else
+	     (format stdout "exception = ~S\n"
+		     (list key (apply format #f (cadr args) (caddr args))))
+	     (loop))))))))
+
+(define (channel-print-value ch val)
+  (format (channel-stdout ch) "value = ~S\n" val))
+
+(define (channel-print-token ch val)
+  (let* ((token (symbol-append (gensym "%%") '%%))
+	 (pair (cons token (object->string val))))
+    (format (channel-stdout ch) "token = ~S\n" pair)
+    (module-define! (channel-token-module ch) token val)))
+
+(define (channel:prompt port)
+  (display "channel> " port)
+  (force-output port))
+
+(define (channel:error port msg . args)
+  (display "ERROR: " port)
+  (apply format port msg args)
+  (newline port))
+
+;;;
+;;; Guile 1.4 compatibility
+;;;
+
+(define guile:eval eval)
+(define eval
+  (if (= (car (procedure-property guile:eval 'arity)) 1)
+    (lambda (x e) (guile:eval x))
+    guile:eval))
+
+(define object->string
+  (if (defined? 'object->string)
+    object->string
+    (lambda (x) (format #f "~S" x))))
+
+;;; channel.scm ends here

node-addon-lilypond/output/share/guile/1.8/ice-9/common-list.scm

@@ -0,0 +1,278 @@
+;;;; common-list.scm --- COMMON LISP list functions for Scheme
+;;;;
+;;;; 	Copyright (C) 1995, 1996, 1997, 2001, 2006 Free Software Foundation, Inc.
+;;;;
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;;
+
+;;; Commentary:
+
+;; These procedures are exported:
+;;  (adjoin e l)
+;;  (union l1 l2)
+;;  (intersection l1 l2)
+;;  (set-difference l1 l2)
+;;  (reduce-init p init l)
+;;  (reduce p l)
+;;  (some pred l . rest)
+;;  (every pred l . rest)
+;;  (notany pred . ls)
+;;  (notevery pred . ls)
+;;  (count-if pred l)
+;;  (find-if pred l)
+;;  (member-if pred l)
+;;  (remove-if pred l)
+;;  (remove-if-not pred l)
+;;  (delete-if! pred l)
+;;  (delete-if-not! pred l)
+;;  (butlast lst n)
+;;  (and? . args)
+;;  (or? . args)
+;;  (has-duplicates? lst)
+;;  (pick p l)
+;;  (pick-mappings p l)
+;;  (uniq l)
+;;
+;; See docstrings for each procedure for more info.  See also module
+;; `(srfi srfi-1)' for a complete list handling library.
+
+;;; Code:
+
+(define-module (ice-9 common-list)
+  :export (adjoin union intersection set-difference reduce-init reduce
+	   some every notany notevery count-if find-if member-if remove-if
+	   remove-if-not delete-if! delete-if-not! butlast and? or?
+	   has-duplicates? pick pick-mappings uniq))
+
+;;"comlist.scm" Implementation of COMMON LISP list functions for Scheme
+; Copyright (C) 1991, 1993, 1995 Aubrey Jaffer.
+;
+;Permission to copy this software, to redistribute it, and to use it
+;for any purpose is granted, subject to the following restrictions and
+;understandings.
+;
+;1.  Any copy made of this software must include this copyright notice
+;in full.
+;
+;2.  I have made no warrantee or representation that the operation of
+;this software will be error-free, and I am under no obligation to
+;provide any services, by way of maintenance, update, or otherwise.
+;
+;3.  In conjunction with products arising from the use of this
+;material, there shall be no use of my name in any advertising,
+;promotional, or sales literature without prior written consent in
+;each case.
+
+(define (adjoin e l)
+  "Return list L, possibly with element E added if it is not already in L."
+  (if (memq e l) l (cons e l)))
+
+(define (union l1 l2)
+  "Return a new list that is the union of L1 and L2.
+Elements that occur in both lists occur only once in
+the result list."
+  (cond ((null? l1) l2)
+	((null? l2) l1)
+	(else (union (cdr l1) (adjoin (car l1) l2)))))
+
+(define (intersection l1 l2)
+  "Return a new list that is the intersection of L1 and L2.
+Only elements that occur in both lists occur in the result list."
+  (if (null? l2) l2
+      (let loop ((l1 l1) (result '()))
+	(cond ((null? l1) (reverse! result))
+	      ((memv (car l1) l2) (loop (cdr l1) (cons (car l1) result)))
+	      (else (loop (cdr l1) result))))))
+
+(define (set-difference l1 l2)
+  "Return elements from list L1 that are not in list L2."
+  (let loop ((l1 l1) (result '()))
+    (cond ((null? l1) (reverse! result))
+	  ((memv (car l1) l2) (loop (cdr l1) result))
+	  (else (loop (cdr l1) (cons (car l1) result))))))
+
+(define (reduce-init p init l)
+  "Same as `reduce' except it implicitly inserts INIT at the start of L."
+  (if (null? l)
+      init
+      (reduce-init p (p init (car l)) (cdr l))))
+
+(define (reduce p l)
+  "Combine all the elements of sequence L using a binary operation P.
+The combination is left-associative.  For example, using +, one can
+add up all the elements.  `reduce' allows you to apply a function which
+accepts only two arguments to more than 2 objects.  Functional
+programmers usually refer to this as foldl."
+  (cond ((null? l) l)
+	((null? (cdr l)) (car l))
+	(else (reduce-init p (car l) (cdr l)))))
+
+(define (some pred l . rest)
+  "PRED is a boolean function of as many arguments as there are list
+arguments to `some', i.e., L plus any optional arguments.  PRED is
+applied to successive elements of the list arguments in order.  As soon
+as one of these applications returns a true value, return that value.
+If no application returns a true value, return #f.
+All the lists should have the same length."
+  (cond ((null? rest)
+	 (let mapf ((l l))
+	   (and (not (null? l))
+		(or (pred (car l)) (mapf (cdr l))))))
+	(else (let mapf ((l l) (rest rest))
+		(and (not (null? l))
+		     (or (apply pred (car l) (map car rest))
+			 (mapf (cdr l) (map cdr rest))))))))
+
+(define (every pred l . rest)
+  "Return #t iff every application of PRED to L, etc., returns #t.
+Analogous to `some' except it returns #t if every application of
+PRED is #t and #f otherwise."
+  (cond ((null? rest)
+	 (let mapf ((l l))
+	   (or (null? l)
+	       (and (pred (car l)) (mapf (cdr l))))))
+	(else (let mapf ((l l) (rest rest))
+		(or (null? l)
+		    (and (apply pred (car l) (map car rest))
+			 (mapf (cdr l) (map cdr rest))))))))
+
+(define (notany pred . ls)
+  "Return #t iff every application of PRED to L, etc., returns #f.
+Analogous to some but returns #t if no application of PRED returns a
+true value or #f as soon as any one does."
+  (not (apply some pred ls)))
+
+(define (notevery pred . ls)
+  "Return #t iff there is an application of PRED to L, etc., that returns #f.
+Analogous to some but returns #t as soon as an application of PRED returns #f,
+or #f otherwise."
+  (not (apply every pred ls)))
+
+(define (count-if pred l)
+  "Return the number of elements in L for which (PRED element) returns true."
+  (let loop ((n 0) (l l))
+    (cond ((null? l) n)
+	  ((pred (car l)) (loop (+ n 1) (cdr l)))
+	  (else (loop n (cdr l))))))
+
+(define (find-if pred l)
+  "Search for the first element in L for which (PRED element) returns true.
+If found, return that element, otherwise return #f."
+  (cond ((null? l) #f)
+	((pred (car l)) (car l))
+	(else (find-if pred (cdr l)))))
+
+(define (member-if pred l)
+  "Return the first sublist of L for whose car PRED is true."
+  (cond ((null? l) #f)
+	((pred (car l)) l)
+	(else (member-if pred (cdr l)))))
+
+(define (remove-if pred l)
+  "Remove all elements from L where (PRED element) is true.
+Return everything that's left."
+  (let loop ((l l) (result '()))
+    (cond ((null? l) (reverse! result))
+	  ((pred (car l)) (loop (cdr l) result))
+	  (else (loop (cdr l) (cons (car l) result))))))
+
+(define (remove-if-not pred l)
+  "Remove all elements from L where (PRED element) is #f.
+Return everything that's left."
+  (let loop ((l l) (result '()))
+    (cond ((null? l) (reverse! result))
+	  ((not (pred (car l))) (loop (cdr l) result))
+	  (else (loop (cdr l) (cons (car l) result))))))
+
+(define (delete-if! pred l)
+  "Destructive version of `remove-if'."
+  (let delete-if ((l l))
+    (cond ((null? l) '())
+	  ((pred (car l)) (delete-if (cdr l)))
+	  (else
+	   (set-cdr! l (delete-if (cdr l)))
+	   l))))
+
+(define (delete-if-not! pred l)
+  "Destructive version of `remove-if-not'."
+  (let delete-if-not ((l l))
+    (cond ((null? l) '())
+	  ((not (pred (car l))) (delete-if-not (cdr l)))
+	  (else
+	   (set-cdr! l (delete-if-not (cdr l)))
+	   l))))
+
+(define (butlast lst n)
+  "Return all but the last N elements of LST."
+  (letrec ((l (- (length lst) n))
+	   (bl (lambda (lst n)
+		 (cond ((null? lst) lst)
+		       ((positive? n)
+			(cons (car lst) (bl (cdr lst) (+ -1 n))))
+		       (else '())))))
+    (bl lst (if (negative? n)
+		(error "negative argument to butlast" n)
+		l))))
+
+(define (and? . args)
+  "Return #t iff all of ARGS are true."
+  (cond ((null? args) #t)
+	((car args) (apply and? (cdr args)))
+	(else #f)))
+
+(define (or? . args)
+  "Return #t iff any of ARGS is true."
+  (cond ((null? args) #f)
+	((car args) #t)
+	(else (apply or? (cdr args)))))
+
+(define (has-duplicates? lst)
+  "Return #t iff 2 members of LST are equal?, else #f."
+  (cond ((null? lst) #f)
+	((member (car lst) (cdr lst)) #t)
+	(else (has-duplicates? (cdr lst)))))
+
+(define (pick p l)
+  "Apply P to each element of L, returning a list of elts
+for which P returns a non-#f value."
+  (let loop ((s '())
+	     (l l))
+    (cond
+     ((null? l) 	s)
+     ((p (car l))	(loop (cons (car l) s) (cdr l)))
+     (else		(loop s (cdr l))))))
+
+(define (pick-mappings p l)
+  "Apply P to each element of L, returning a list of the
+non-#f return values of P."
+  (let loop ((s '())
+	     (l l))
+    (cond
+     ((null? l) 	s)
+     ((p (car l)) =>	(lambda (mapping) (loop (cons mapping s) (cdr l))))
+     (else		(loop s (cdr l))))))
+
+(define (uniq l)
+  "Return a list containing elements of L, with duplicates removed."
+  (let loop ((acc '())
+	     (l l))
+    (if (null? l)
+	(reverse! acc)
+	(loop (if (memq (car l) acc)
+		  acc
+		  (cons (car l) acc))
+	      (cdr l)))))
+
+;;; common-list.scm ends here

node-addon-lilypond/output/share/guile/1.8/ice-9/debug.scm

@@ -0,0 +1,134 @@
+;;;; 	Copyright (C) 1996, 1997, 1998, 1999, 2001, 2006 Free Software Foundation
+;;;; 
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;;
+;;;; The author can be reached at djurfeldt@nada.kth.se
+;;;; Mikael Djurfeldt, SANS/NADA KTH, 10044 STOCKHOLM, SWEDEN
+;;;;
+
+
+(define-module (ice-9 debug)
+  :export (frame-number->index trace untrace trace-stack untrace-stack))
+
+
+;;; {Misc}
+;;;
+(define (frame-number->index n . stack)
+  (let ((stack (if (null? stack)
+		   (fluid-ref the-last-stack)
+		   (car stack))))
+    (if (memq 'backwards (debug-options))
+	n
+	(- (stack-length stack) n 1))))
+
+
+;;; {Trace}
+;;;
+;;; This code is just an experimental prototype (e. g., it is not
+;;; thread safe), but since it's at the same time useful, it's
+;;; included anyway.
+;;;
+(define traced-procedures '())
+
+(define (trace . args)
+  (if (null? args)
+      (nameify traced-procedures)
+      (begin
+	(for-each (lambda (proc)
+		    (if (not (procedure? proc))
+			(error "trace: Wrong type argument:" proc))
+		    (set-procedure-property! proc 'trace #t)
+		    (if (not (memq proc traced-procedures))
+			(set! traced-procedures
+			      (cons proc traced-procedures))))
+		  args)
+	(trap-set! apply-frame-handler trace-entry)
+	(trap-set! exit-frame-handler trace-exit)
+	;; We used to reset `trace-level' here to 0, but this is wrong
+	;; if `trace' itself is being traced, since `trace-exit' will
+	;; then decrement `trace-level' to -1!  It shouldn't actually
+	;; be necessary to set `trace-level' here at all.
+	(debug-enable 'trace)
+	(nameify args))))
+
+(define (untrace . args)
+  (if (and (null? args)
+	   (not (null? traced-procedures)))
+      (apply untrace traced-procedures)
+      (begin
+	(for-each (lambda (proc)
+		    (set-procedure-property! proc 'trace #f)
+		    (set! traced-procedures (delq! proc traced-procedures)))
+		  args)
+	(if (null? traced-procedures)
+	    (debug-disable 'trace))
+	(nameify args))))
+
+(define (nameify ls)
+  (map (lambda (proc)
+	 (let ((name (procedure-name proc)))
+	   (or name proc)))
+       ls))
+
+(define trace-level 0)
+(add-hook! abort-hook (lambda () (set! trace-level 0)))
+
+(define traced-stack-ids (list 'repl-stack))
+(define trace-all-stacks? #f)
+
+(define (trace-stack id)
+  "Add ID to the set of stack ids for which tracing is active.
+If `#t' is in this set, tracing is active regardless of stack context.
+To remove ID again, use `untrace-stack'.  If you add the same ID twice
+using `trace-stack', you will need to remove it twice."
+  (set! traced-stack-ids (cons id traced-stack-ids))
+  (set! trace-all-stacks? (memq #t traced-stack-ids)))
+
+(define (untrace-stack id)
+  "Remove ID from the set of stack ids for which tracing is active."
+  (set! traced-stack-ids (delq1! id traced-stack-ids))
+  (set! trace-all-stacks? (memq #t traced-stack-ids)))
+
+(define (trace-entry key cont tail)
+  (if (or trace-all-stacks?
+	  (memq (stack-id cont) traced-stack-ids))
+      (let ((cep (current-error-port))
+	    (frame (last-stack-frame cont)))
+	(if (not tail)
+	    (set! trace-level (+ trace-level 1)))
+	(let indent ((n trace-level))
+	  (cond ((> n 1) (display "|  " cep) (indent (- n 1)))))
+	(display-application frame cep)
+	(newline cep)))
+  ;; It's not necessary to call the continuation since
+  ;; execution will continue if the handler returns
+  ;(cont #f)
+  )
+
+(define (trace-exit key cont retval)
+  (if (or trace-all-stacks?
+	  (memq (stack-id cont) traced-stack-ids))
+      (let ((cep (current-error-port)))
+	(set! trace-level (- trace-level 1))
+	(let indent ((n trace-level))
+	  (cond ((> n 0) (display "|  " cep) (indent (- n 1)))))
+	(write retval cep)
+	(newline cep))))
+
+
+;;; A fix to get the error handling working together with the module system.
+;;;
+;;; XXX - Still needed?
+(module-set! the-root-module 'debug-options debug-options)

node-addon-lilypond/output/share/guile/1.8/ice-9/debugger.scm

@@ -0,0 +1,146 @@
+;;;; Guile Debugger
+
+;;; Copyright (C) 1999, 2001, 2002, 2006 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 debugger)
+  #:use-module (ice-9 debugger command-loop)
+  #:use-module (ice-9 debugger state)
+  #:use-module (ice-9 debugger utils)
+  #:use-module (ice-9 format)
+  #:export (debug-stack
+	    debug
+	    debug-last-error
+	    debugger-error
+	    debugger-quit
+	    debugger-input-port
+	    debugger-output-port
+	    debug-on-error)
+  #:no-backtrace)
+
+;;; The old (ice-9 debugger) has been factored into its constituent
+;;; parts:
+;;;
+;;; (ice-9 debugger) - public interface to all of the following
+;;;
+;;; (... commands) - procedures implementing the guts of the commands
+;;;                  provided by the interactive debugger
+;;;
+;;; (... command-loop) - binding these commands into the interactive
+;;;                      debugger command loop
+;;;
+;;; (... state) - implementation of an object that tracks current
+;;;               debugger state
+;;;
+;;; (... utils) - utilities for printing out frame and stack
+;;;               information in various formats
+;;;
+;;; The division between (... commands) and (... command-loop) exists
+;;; because I (NJ) have another generic command loop implementation
+;;; under development, and I want to be able to switch easily between
+;;; that and the command loop implementation here.  Thus the
+;;; procedures in this file delegate to a debugger command loop
+;;; implementation via the `debugger-command-loop-*' interface.  The
+;;; (ice-9 debugger command-loop) implementation can be replaced by
+;;; any other that implements the `debugger-command-loop-*' interface
+;;; simply by changing the relevant #:use-module line above.
+;;;
+;;; - Neil Jerram <neil@ossau.uklinux.net> 2002-10-26, updated 2005-07-09
+
+(define *not-yet-introduced* #t)
+
+(define (debug-stack stack . flags)
+  "Invoke the Guile debugger to explore the specified @var{stack}.
+
+@var{flags}, if present, are keywords indicating characteristics of
+the debugging session: the valid keywords are as follows.
+
+@table @code
+@item #:continuable
+Indicates that the debugger is being invoked from a context (such as
+an evaluator trap handler) where it is possible to return from the
+debugger and continue normal code execution.  This enables the
+@dfn{continuing execution} commands, for example @code{continue} and
+@code{step}.
+
+@item #:with-introduction
+Indicates that the debugger should display an introductory message.
+@end table"
+  (start-stack 'debugger
+    (let ((state (apply make-state stack 0 flags)))
+      (with-input-from-port (debugger-input-port)
+	(lambda ()
+	  (with-output-to-port (debugger-output-port)
+	    (lambda ()
+	      (if (or *not-yet-introduced*
+		      (memq #:with-introduction flags))
+		  (let ((ssize (stack-length stack)))
+		    (display "This is the Guile debugger -- for help, type `help'.\n")
+		    (set! *not-yet-introduced* #f)
+		    (if (= ssize 1)
+			(display "There is 1 frame on the stack.\n\n")
+			(format #t "There are ~A frames on the stack.\n\n" ssize))))
+	      (write-state-short state)
+	      (debugger-command-loop state))))))))
+
+(define (debug)
+  "Invoke the Guile debugger to explore the context of the last error."
+  (let ((stack (fluid-ref the-last-stack)))
+    (if stack
+	(debug-stack stack)
+	(display "Nothing to debug.\n"))))
+
+(define debug-last-error debug)
+
+(define (debugger-error message)
+  "Signal a debugger usage error with message @var{message}."
+  (debugger-command-loop-error message))
+
+(define (debugger-quit)
+  "Exit the debugger."
+  (debugger-command-loop-quit))
+
+;;; {Debugger Input and Output Ports}
+
+(define debugger-input-port
+  (let ((input-port (current-input-port)))
+    (make-procedure-with-setter
+     (lambda () input-port)
+     (lambda (port) (set! input-port port)))))
+
+(define debugger-output-port
+  (let ((output-port (current-output-port)))
+    (make-procedure-with-setter
+     (lambda () output-port)
+     (lambda (port) (set! output-port port)))))
+
+;;; {Debug on Error}
+
+(define (debug-on-error syms)
+  "Enable or disable debug on error."
+  (set! lazy-handler-dispatch
+	(if syms
+	    (lambda (key . args)
+	      (if (memq key syms)
+		  (begin
+		    (debug-stack (make-stack #t lazy-handler-dispatch)
+				 #:with-introduction
+				 #:continuable)
+		    (throw 'abort key)))
+	      (apply default-lazy-handler key args))
+	    default-lazy-handler)))
+
+;;; (ice-9 debugger) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugger/command-loop.scm

@@ -0,0 +1,542 @@
+;;;; Guile Debugger command loop
+
+;;; Copyright (C) 1999, 2001, 2002, 2003, 2006 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 debugger command-loop)
+  #:use-module ((ice-9 debugger commands) :prefix debugger:)
+  #:export (debugger-command-loop
+	    debugger-command-loop-error
+	    debugger-command-loop-quit)
+  #:no-backtrace)
+
+;;; {Interface used by (ice-9 debugger).}
+
+(define (debugger-command-loop state)
+  (read-and-dispatch-commands state (current-input-port)))
+
+(define (debugger-command-loop-error message)
+  (user-error message))
+
+(define (debugger-command-loop-quit)
+  (throw 'exit-debugger))
+
+;;; {Implementation.}
+  
+(define debugger-prompt "debug> ")
+
+(define (debugger-handler key . args)
+  (case key
+    ((exit-debugger) #f)
+    ((signal)
+     ;; Restore stack
+     (fluid-set! the-last-stack (fluid-ref before-signal-stack))
+     (apply display-error #f (current-error-port) args))
+    (else
+     (display "Internal debugger error:\n")
+     (save-stack debugger-handler)
+     (apply throw key args)))
+  (throw 'exit-debugger))		;Pop the stack
+
+(define (read-and-dispatch-commands state port)
+  (catch 'exit-debugger
+    (lambda ()
+      (lazy-catch #t
+        (lambda ()
+	  (with-fluids ((last-command #f))
+	    (let loop ()
+	      (read-and-dispatch-command state port)
+	      (loop))))
+	debugger-handler))
+    (lambda args
+      *unspecified*)))
+
+(define set-readline-prompt! #f)
+
+(define (read-and-dispatch-command state port)
+  (if (using-readline?)
+      (begin
+	;; Import set-readline-prompt! if we haven't already.
+	(or set-readline-prompt!
+	    (set! set-readline-prompt!
+		  (module-ref (resolve-module '(ice-9 readline))
+			      'set-readline-prompt!)))
+	(set-readline-prompt! debugger-prompt debugger-prompt))
+      (display debugger-prompt))
+  (force-output)			;This should not be necessary...
+  (let ((token (read-token port)))
+    (cond ((eof-object? token)
+	   (throw 'exit-debugger))
+	  ((not token)
+	   (discard-rest-of-line port)
+	   (catch-user-errors port (lambda () (run-last-command state))))
+	  (else
+	   (catch-user-errors port
+	     (lambda ()
+	       (dispatch-command token command-table state port)))))))
+
+(define (run-last-command state)
+  (let ((procedure (fluid-ref last-command)))
+    (if procedure
+	(procedure state))))
+
+(define (catch-user-errors port thunk)
+  (catch 'debugger-user-error
+	 thunk
+	 (lambda (key . objects)
+	   (apply user-warning objects)
+	   (discard-rest-of-line port))))
+
+(define last-command (make-fluid))
+
+(define (user-warning . objects)
+  (for-each (lambda (object)
+	      (display object))
+	    objects)
+  (newline))
+
+(define (user-error . objects)
+  (apply throw 'debugger-user-error objects))
+
+;;;; Command dispatch
+
+(define (dispatch-command string table state port)
+  (let ((value (command-table-value table string)))
+    (if value
+	(dispatch-command/value value state port)
+	(user-error "Unknown command: " string))))
+
+(define (dispatch-command/value value state port)
+  (cond ((command? value)
+	 (dispatch-command/command value state port))
+	((command-table? value)
+	 (dispatch-command/table value state port))
+	((list? value)
+	 (dispatch-command/name value state port))
+	(else
+	 (error "Unrecognized command-table value: " value))))
+
+(define (dispatch-command/command command state port)
+  (let ((procedure (command-procedure command))
+	(arguments ((command-parser command) port)))
+    (let ((procedure (lambda (state) (apply procedure state arguments))))
+      (warn-about-extra-args port)
+      (fluid-set! last-command procedure)
+      (procedure state))))
+
+(define (warn-about-extra-args port)
+  ;; **** modify this to show the arguments.
+  (let ((char (skip-whitespace port)))
+    (cond ((eof-object? char) #f)
+	  ((char=? #\newline char) (read-char port))
+	  (else
+	   (user-warning "Extra arguments at end of line: "
+			 (read-rest-of-line port))))))
+
+(define (dispatch-command/table table state port)
+  (let ((token (read-token port)))
+    (if (or (eof-object? token)
+	    (not token))
+	(user-error "Command name too short.")
+	(dispatch-command token table state port))))
+
+(define (dispatch-command/name name state port)
+  (let ((value (lookup-command name)))
+    (cond ((not value)
+	   (apply user-error "Unknown command name: " name))
+	  ((command-table? value)
+	   (apply user-error "Partial command name: " name))
+	  (else
+	   (dispatch-command/value value state port)))))
+
+;;;; Command definition
+
+(define (define-command name argument-template procedure)
+  (let ((name (canonicalize-command-name name)))
+    (add-command name
+		 (make-command name
+			       (argument-template->parser argument-template)
+			       (procedure-documentation procedure)
+			       procedure)
+		 command-table)
+    name))
+
+(define (define-command-alias name1 name2)
+  (let ((name1 (canonicalize-command-name name1)))
+    (add-command name1 (canonicalize-command-name name2) command-table)
+    name1))
+
+(define (argument-template->parser template)
+  ;; Deliberately handles only cases that occur in "commands.scm".
+  (cond ((eq? 'tokens template)
+	 (lambda (port)
+	   (let loop ((tokens '()))
+	     (let ((token (read-token port)))
+	       (if (or (eof-object? token)
+		       (not token))
+		   (list (reverse! tokens))
+		   (loop (cons token tokens)))))))
+	((null? template)
+	 (lambda (port)
+	   '()))
+	((and (pair? template)
+	      (null? (cdr template))
+	      (eq? 'object (car template)))
+	 (lambda (port)
+	   (list (read port))))
+	((and (pair? template)
+	      (equal? ''optional (car template))
+	      (pair? (cdr template))
+	      (null? (cddr template)))
+	 (case (cadr template)
+	   ((token)
+	    (lambda (port)
+	      (let ((token (read-token port)))
+		(if (or (eof-object? token)
+			(not token))
+		    (list #f)
+		    (list token)))))
+	   ((exact-integer)
+	    (lambda (port)
+	      (list (parse-optional-exact-integer port))))
+	   ((exact-nonnegative-integer)
+	    (lambda (port)
+	      (list (parse-optional-exact-nonnegative-integer port))))
+	   ((object)
+	    (lambda (port)
+	      (list (parse-optional-object port))))
+	   (else
+	    (error "Malformed argument template: " template))))
+	(else
+	 (error "Malformed argument template: " template))))
+
+(define (parse-optional-exact-integer port)
+  (let ((object (parse-optional-object port)))
+    (if (or (not object)
+	    (and (integer? object)
+		 (exact? object)))
+	object
+	(user-error "Argument not an exact integer: " object))))
+
+(define (parse-optional-exact-nonnegative-integer port)
+  (let ((object (parse-optional-object port)))
+    (if (or (not object)
+	    (and (integer? object)
+		 (exact? object)
+		 (not (negative? object))))
+	object
+	(user-error "Argument not an exact non-negative integer: " object))))
+
+(define (parse-optional-object port)
+  (let ((terminator (skip-whitespace port)))
+    (if (or (eof-object? terminator)
+	    (eq? #\newline terminator))
+	#f
+	(let ((object (read port)))
+	  (if (eof-object? object)
+	      #f
+	      object)))))
+
+;;;; Command tables
+
+(define (lookup-command name)
+  (let loop ((table command-table) (strings name))
+    (let ((value (command-table-value table (car strings))))
+      (cond ((or (not value) (null? (cdr strings))) value)
+	    ((command-table? value) (loop value (cdr strings)))
+	    (else #f)))))
+
+(define (command-table-value table string)
+  (let ((entry (command-table-entry table string)))
+    (and entry
+	 (caddr entry))))
+
+(define (command-table-entry table string)
+  (let loop ((entries (command-table-entries table)))
+    (and (not (null? entries))
+	 (let ((entry (car entries)))
+	   (if (and (<= (cadr entry)
+			(string-length string)
+			(string-length (car entry)))
+		    (= (string-length string)
+		       (match-strings (car entry) string)))
+	       entry
+	       (loop (cdr entries)))))))
+
+(define (match-strings s1 s2)
+  (let ((n (min (string-length s1) (string-length s2))))
+    (let loop ((i 0))
+      (cond ((= i n) i)
+	    ((char=? (string-ref s1 i) (string-ref s2 i)) (loop (+ i 1)))
+	    (else i)))))
+
+(define (write-command-name name)
+  (display (car name))
+  (for-each (lambda (string)
+	      (write-char #\space)
+	      (display string))
+	    (cdr name)))
+
+(define (add-command name value table)
+  (let loop ((strings name) (table table))
+    (let ((entry
+	   (or (let loop ((entries (command-table-entries table)))
+		 (and (not (null? entries))
+		      (if (string=? (car strings) (caar entries))
+			  (car entries)
+			  (loop (cdr entries)))))
+	       (let ((entry (list (car strings) #f #f)))
+		 (let ((entries
+			(let ((entries (command-table-entries table)))
+			  (if (or (null? entries)
+				  (string<? (car strings) (caar entries)))
+			      (cons entry entries)
+			      (begin
+				(let loop ((prev entries) (this (cdr entries)))
+				  (if (or (null? this)
+					  (string<? (car strings) (caar this)))
+				      (set-cdr! prev (cons entry this))
+				      (loop this (cdr this))))
+				entries)))))
+		   (compute-string-abbreviations! entries)
+		   (set-command-table-entries! table entries))
+		 entry))))
+      (if (null? (cdr strings))
+	  (set-car! (cddr entry) value)
+	  (loop (cdr strings)
+		(if (command-table? (caddr entry))
+		    (caddr entry)
+		    (let ((table (make-command-table '())))
+		      (set-car! (cddr entry) table)
+		      table)))))))
+
+(define (canonicalize-command-name name)
+  (cond ((and (string? name)
+	      (not (string-null? name)))
+	 (list name))
+	((let loop ((name name))
+	   (and (pair? name)
+		(string? (car name))
+		(not (string-null? (car name)))
+		(or (null? (cdr name))
+		    (loop (cdr name)))))
+	 name)
+	(else
+	 (error "Illegal command name: " name))))
+
+(define (compute-string-abbreviations! entries)
+  (let loop ((entries entries) (index 0))
+    (let ((groups '()))
+      (for-each
+       (lambda (entry)
+	 (let* ((char (string-ref (car entry) index))
+		(group (assv char groups)))
+	   (if group
+	       (set-cdr! group (cons entry (cdr group)))
+	       (set! groups
+		     (cons (list char entry)
+			   groups)))))
+       entries)
+      (for-each
+       (lambda (group)
+	 (let ((index (+ index 1)))
+	   (if (null? (cddr group))
+	       (set-car! (cdadr group) index)
+	       (loop (let ((entry
+			    (let loop ((entries (cdr group)))
+			      (and (not (null? entries))
+				   (if (= index (string-length (caar entries)))
+				       (car entries)
+				       (loop (cdr entries)))))))
+		       (if entry
+			   (begin
+			     (set-car! (cdr entry) index)
+			     (delq entry (cdr group)))
+			   (cdr group)))
+		     index))))
+       groups))))
+
+;;;; Data structures
+
+(define command-table-rtd (make-record-type "command-table" '(entries)))
+(define make-command-table (record-constructor command-table-rtd '(entries)))
+(define command-table? (record-predicate command-table-rtd))
+(define command-table-entries (record-accessor command-table-rtd 'entries))
+(define set-command-table-entries!
+  (record-modifier command-table-rtd 'entries))
+
+(define command-rtd
+  (make-record-type "command"
+		    '(name parser documentation procedure)))
+
+(define make-command
+  (record-constructor command-rtd
+		      '(name parser documentation procedure)))
+
+(define command? (record-predicate command-rtd))
+(define command-name (record-accessor command-rtd 'name))
+(define command-parser (record-accessor command-rtd 'parser))
+(define command-documentation (record-accessor command-rtd 'documentation))
+(define command-procedure (record-accessor command-rtd 'procedure))
+
+;;;; Character parsing
+
+(define (read-token port)
+  (letrec
+      ((loop
+	(lambda (chars)
+	  (let ((char (peek-char port)))
+	    (cond ((eof-object? char)
+		   (do-eof char chars))
+		  ((char=? #\newline char)
+		   (do-eot chars))
+		  ((char-whitespace? char)
+		   (do-eot chars))
+		  ((char=? #\# char)
+		   (read-char port)
+		   (let ((terminator (skip-comment port)))
+		     (if (eof-object? char)
+			 (do-eof char chars)
+			 (do-eot chars))))
+		  (else
+		   (read-char port)
+		   (loop (cons char chars)))))))
+       (do-eof
+	(lambda (eof chars)
+	  (if (null? chars)
+	      eof
+	      (do-eot chars))))
+       (do-eot
+	(lambda (chars)
+	  (if (null? chars)
+	      #f
+	      (list->string (reverse! chars))))))
+    (skip-whitespace port)
+    (loop '())))
+
+(define (skip-whitespace port)
+  (let ((char (peek-char port)))
+    (cond ((or (eof-object? char)
+	       (char=? #\newline char))
+	   char)
+	  ((char-whitespace? char)
+	   (read-char port)
+	   (skip-whitespace port))
+	  ((char=? #\# char)
+	   (read-char port)
+	   (skip-comment port))
+	  (else char))))
+
+(define (skip-comment port)
+  (let ((char (peek-char port)))
+    (if (or (eof-object? char)
+	    (char=? #\newline char))
+	char
+	(begin
+	  (read-char port)
+	  (skip-comment port)))))
+
+(define (read-rest-of-line port)
+  (let loop ((chars '()))
+    (let ((char (read-char port)))
+      (if (or (eof-object? char)
+	      (char=? #\newline char))
+	  (list->string (reverse! chars))
+	  (loop (cons char chars))))))
+
+(define (discard-rest-of-line port)
+  (let loop ()
+    (if (not (let ((char (read-char port)))
+	       (or (eof-object? char)
+		   (char=? #\newline char))))
+	(loop))))
+
+;;;; Commands
+
+(define command-table (make-command-table '()))
+
+(define-command "help" 'tokens
+  (lambda (state tokens)
+    "Type \"help\" followed by a command name for full documentation."
+    (let loop ((name (if (null? tokens) '("help") tokens)))
+      (let ((value (lookup-command name)))
+	(cond ((not value)
+	       (write-command-name name)
+	       (display " is not a known command name.")
+	       (newline))
+	      ((command? value)
+	       (display (command-documentation value))
+	       (newline)
+	       (if (equal? '("help") (command-name value))
+		   (begin
+		     (display "Available commands are:")
+		     (newline)
+		     (for-each (lambda (entry)
+				 (if (not (list? (caddr entry)))
+				     (begin
+				       (display "  ")
+				       (display (car entry))
+				       (newline))))
+			       (command-table-entries command-table)))))
+	      ((command-table? value)
+	       (display "The \"")
+	       (write-command-name name)
+	       (display "\" command requires a subcommand.")
+	       (newline)
+	       (display "Available subcommands are:")
+	       (newline)
+	       (for-each (lambda (entry)
+			   (if (not (list? (caddr entry)))
+			       (begin
+				 (display "  ")
+				 (write-command-name name)
+				 (write-char #\space)
+				 (display (car entry))
+				 (newline))))
+			 (command-table-entries value)))
+	      ((list? value)
+	       (loop value))
+	      (else
+	       (error "Unknown value from lookup-command:" value)))))
+    state))
+
+(define-command "frame" '('optional exact-nonnegative-integer) debugger:frame)
+
+(define-command "position" '() debugger:position)
+
+(define-command "up" '('optional exact-integer) debugger:up)
+
+(define-command "down" '('optional exact-integer) debugger:down)
+
+(define-command "backtrace" '('optional exact-integer) debugger:backtrace)
+
+(define-command "evaluate" '(object) debugger:evaluate)
+
+(define-command '("info" "args") '() debugger:info-args)
+
+(define-command '("info" "frame") '() debugger:info-frame)
+
+(define-command "quit" '()
+  (lambda (state)
+    "Exit the debugger."
+    (debugger-command-loop-quit)))
+
+(define-command-alias "f" "frame")
+(define-command-alias '("info" "f") '("info" "frame"))
+(define-command-alias "bt" "backtrace")
+(define-command-alias "where" "backtrace")
+(define-command-alias "p" "evaluate")
+(define-command-alias '("info" "stack") "backtrace")

node-addon-lilypond/output/share/guile/1.8/ice-9/debugger/commands.scm

@@ -0,0 +1,154 @@
+;;;; (ice-9 debugger commands) -- debugger commands
+
+;;; Copyright (C) 2002, 2006 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 debugger commands)
+  #:use-module (ice-9 debug)
+  #:use-module (ice-9 debugger)
+  #:use-module (ice-9 debugger state)
+  #:use-module (ice-9 debugger utils)
+  #:export (backtrace
+	    evaluate
+	    info-args
+	    info-frame
+	    position
+	    up
+	    down
+	    frame))
+
+(define (backtrace state n-frames)
+  "Print backtrace of all stack frames, or innermost COUNT frames.
+With a negative argument, print outermost -COUNT frames.
+If the number of frames isn't explicitly given, the debug option
+`depth' determines the maximum number of frames printed."
+  (let ((stack (state-stack state)))
+    ;; Kludge around lack of call-with-values.
+    (let ((values
+	   (lambda (start end)
+	     (display-backtrace stack
+				(current-output-port)
+				(if (memq 'backwards (debug-options))
+				    start
+				    (- end 1))
+				(- end start))
+	     )))
+      (let ((end (stack-length stack)))
+	(cond ((not n-frames) ;(>= (abs n-frames) end))
+	       (values 0 (min end (cadr (memq 'depth (debug-options))))))
+	      ((>= n-frames 0)
+	       (values 0 n-frames))
+	      (else
+	       (values (+ end n-frames) end)))))))
+
+(define (eval-handler key . args)
+  (let ((stack (make-stack #t eval-handler)))
+    (if (= (length args) 4)
+	(apply display-error stack (current-error-port) args)
+	;; We want display-error to be the "final common pathway"
+	(catch #t
+	       (lambda ()
+		 (apply bad-throw key args))
+	       (lambda (key . args)
+		 (apply display-error stack (current-error-port) args)))))
+  (throw 'continue))
+
+(define (evaluate state expression)
+  "Evaluate an expression in the environment of the selected stack frame.
+The expression must appear on the same line as the command, however it
+may be continued over multiple lines."
+  (let ((source (frame-source (stack-ref (state-stack state)
+					 (state-index state)))))
+    (if (not source)
+	(display "No environment for this frame.\n")
+	(catch 'continue
+	       (lambda ()
+		 (lazy-catch #t
+			     (lambda ()
+			       (let* ((expr
+				       ;; We assume that no one will
+				       ;; really want to evaluate a
+				       ;; string (since it is
+				       ;; self-evaluating); so if we
+				       ;; have a string here, read the
+				       ;; expression to evaluate from
+				       ;; it.
+				       (if (string? expression)
+					   (with-input-from-string expression
+								   read)
+					   expression))
+				      (env (memoized-environment source))
+				      (value (local-eval expr env)))
+				 (write expr)
+				 (display " => ")
+				 (write value)
+				 (newline)))
+			     eval-handler))
+	       (lambda args args)))))
+
+(define (info-args state)
+  "Display the argument variables of the current stack frame.
+Arguments can also be seen in the backtrace, but are presented more
+clearly by this command."
+  (let ((index (state-index state)))
+    (let ((frame (stack-ref (state-stack state) index)))
+      (write-frame-index-long frame)
+      (write-frame-args-long frame))))
+
+(define (info-frame state)
+  "Display a verbose description of the selected frame.  The
+information that this command provides is equivalent to what can be
+deduced from the one line summary for the frame that appears in a
+backtrace, but is presented and explained more clearly."
+  (write-state-long state))
+
+(define (position state)
+  "Display the name of the source file that the current expression
+comes from, and the line and column number of the expression's opening
+parenthesis within that file.  This information is only available when
+the 'positions read option is enabled."
+  (let* ((frame (stack-ref (state-stack state) (state-index state)))
+	 (source (frame-source frame)))
+    (if (not source)
+	(display "No source available for this frame.")
+	(let ((position (source-position source)))
+	  (if (not position)
+	      (display "No position information available for this frame.")
+	      (display-position position)))))
+  (newline))
+
+(define (up state n)
+  "Move @var{n} frames up the stack.  For positive @var{n}, this
+advances toward the outermost frame, to lower frame numbers, to
+frames that have existed longer.  @var{n} defaults to one."
+  (set-stack-index! state (+ (state-index state) (or n 1)))
+  (write-state-short state))
+
+(define (down state n)
+  "Move @var{n} frames down the stack.  For positive @var{n}, this
+advances toward the innermost frame, to higher frame numbers, to frames
+that were created more recently.  @var{n} defaults to one."
+  (set-stack-index! state (- (state-index state) (or n 1)))
+  (write-state-short state))
+
+(define (frame state n)
+  "Select and print a stack frame.
+With no argument, print the selected stack frame.  (See also \"info frame\").
+An argument specifies the frame to select; it must be a stack-frame number."
+  (if n (set-stack-index! state (frame-number->index n (state-stack state))))
+  (write-state-short state))
+
+;;; (ice-9 debugger commands) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugger/state.scm

@@ -0,0 +1,47 @@
+;;;; (ice-9 debugger state) -- debugger state representation
+
+;;; Copyright (C) 2002, 2006 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 debugger state)
+  #:export (make-state
+	    state-stack
+	    state-index
+	    state-flags
+	    set-stack-index!))
+
+(define state-rtd (make-record-type "debugger-state" '(stack index flags)))
+(define state? (record-predicate state-rtd))
+(define make-state
+  (let ((make-state-internal (record-constructor state-rtd
+						 '(stack index flags))))
+    (lambda (stack index . flags)
+      (make-state-internal stack index flags))))
+(define state-stack (record-accessor state-rtd 'stack))
+(define state-index (record-accessor state-rtd 'index))
+(define state-flags (record-accessor state-rtd 'flags))
+
+(define set-state-index! (record-modifier state-rtd 'index))
+
+(define (set-stack-index! state index)
+  (let* ((stack (state-stack state))
+	 (ssize (stack-length stack)))
+    (set-state-index! state
+		      (cond ((< index 0) 0)
+			    ((>= index ssize) (- ssize 1))
+			    (else index)))))
+
+;;; (ice-9 debugger state) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugger/trc.scm

@@ -0,0 +1,63 @@
+;;;; (ice-9 debugger trc) -- tracing for Guile debugger code
+
+;;; Copyright (C) 2002, 2006 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+(define-module (ice-9 debugger trc)
+  #:export (trc trc-syms trc-all trc-none trc-add trc-remove trc-port))
+
+(define *syms* #f)
+
+(define (trc-set! syms)
+  (set! *syms* syms))
+
+(define (trc-syms . syms)
+  (trc-set! syms))
+
+(define (trc-all)
+  (trc-set! #f))
+
+(define (trc-none)
+  (trc-set! '()))
+
+(define (trc-add sym)
+  (trc-set! (cons sym *syms*)))
+
+(define (trc-remove sym)
+  (trc-set! (delq1! sym *syms*)))
+
+(define (trc sym . args)
+  (if (or (not *syms*)
+	  (memq sym *syms*))
+      (let ((port (trc-port)))
+	(write sym port)
+	(display ":" port)
+	(for-each (lambda (arg)
+		    (display " " port)
+		    (write arg port))
+		  args)
+	(newline port))))
+
+(define trc-port
+  (let ((port (current-error-port)))
+    (make-procedure-with-setter
+     (lambda () port)
+     (lambda (p) (set! port p)))))
+
+;; Default to no tracing.
+(trc-none)
+
+;;; (ice-9 debugger trc) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugger/utils.scm

@@ -0,0 +1,203 @@
+
+(define-module (ice-9 debugger utils)
+  #:use-module (ice-9 debugger state)
+  #:export (display-position
+	    source-position
+	    write-frame-args-long
+	    write-frame-index-long
+	    write-frame-short/expression
+	    write-frame-short/application
+	    write-frame-long
+	    write-state-long
+	    write-state-short))
+
+;;; Procedures in this module print information about a stack frame.
+;;; The available information is as follows.
+;;;
+;;; * Source code location.
+;;;
+;;; For an evaluation frame, this is the location recorded at the time
+;;; that the expression being evaluated was read, if the 'positions
+;;; read option was enabled at that time.
+;;;
+;;; For an application frame, I'm not yet sure.  Some applications
+;;; seem to have associated source expressions.
+;;;
+;;; * Whether frame is still evaluating its arguments.
+;;;
+;;; Only applies to an application frame.  For example, an expression
+;;; like `(+ (* 2 3) 4)' goes through the following stages of
+;;; evaluation.
+;;;
+;;; (+ (* 2 3) 4)       -- evaluation
+;;; [+ ...              -- application; the car of the evaluation
+;;;                        has been evaluated and found to be a
+;;;                        procedure; before this procedure can
+;;;                        be applied, its arguments must be evaluated
+;;; [+ 6 ...            -- same application after evaluating the
+;;;                        first argument
+;;; [+ 6 4]             -- same application after evaluating all
+;;;                        arguments
+;;; 10                  -- result
+;;;
+;;; * Whether frame is real or tail-recursive.
+;;;
+;;; If a frame is tail-recursive, its containing frame as shown by the
+;;; debugger backtrace doesn't really exist as far as the Guile
+;;; evaluator is concerned.  The effect of this is that when a
+;;; tail-recursive frame returns, it looks as though its containing
+;;; frame returns at the same time.  (And if the containing frame is
+;;; also tail-recursive, _its_ containing frame returns at that time
+;;; also, and so on ...)
+;;;
+;;; A `real' frame is one that is not tail-recursive.
+
+
+(define (write-state-short state)
+  (let* ((frame (stack-ref (state-stack state) (state-index state)))
+	 (source (frame-source frame))
+	 (position (and source (source-position source))))
+    (format #t "Frame ~A at " (frame-number frame))
+    (if position
+	(display-position position)
+	(display "unknown source location"))
+    (newline)
+    (write-char #\tab)
+    (write-frame-short frame)
+    (newline)))
+
+(define (write-state-short* stack index)
+  (write-frame-index-short stack index)
+  (write-char #\space)
+  (write-frame-short (stack-ref stack index))
+  (newline))
+
+(define (write-frame-index-short stack index)
+  (let ((s (number->string (frame-number (stack-ref stack index)))))
+    (display s)
+    (write-char #\:)
+    (write-chars #\space (- 4 (string-length s)))))
+
+(define (write-frame-short frame)
+  (if (frame-procedure? frame)
+      (write-frame-short/application frame)
+      (write-frame-short/expression frame)))
+
+(define (write-frame-short/application frame)
+  (write-char #\[)
+  (write (let ((procedure (frame-procedure frame)))
+	   (or (and (procedure? procedure)
+		    (procedure-name procedure))
+	       procedure)))
+  (if (frame-evaluating-args? frame)
+      (display " ...")
+      (begin
+	(for-each (lambda (argument)
+		    (write-char #\space)
+		    (write argument))
+		  (frame-arguments frame))
+	(write-char #\]))))
+
+;;; Use builtin function instead:
+(set! write-frame-short/application
+      (lambda (frame)
+	(display-application frame (current-output-port) 12)))
+
+(define (write-frame-short/expression frame)
+  (write (let* ((source (frame-source frame))
+		(copy (source-property source 'copy)))
+	   (if (pair? copy)
+	       copy
+	       (unmemoize-expr source)))))
+
+(define (write-state-long state)
+  (let ((index (state-index state)))
+    (let ((frame (stack-ref (state-stack state) index)))
+      (write-frame-index-long frame)
+      (write-frame-long frame))))
+
+(define (write-frame-index-long frame)
+  (display "Stack frame: ")
+  (write (frame-number frame))
+  (if (frame-real? frame)
+      (display " (real)"))
+  (newline))
+
+(define (write-frame-long frame)
+  (if (frame-procedure? frame)
+      (write-frame-long/application frame)
+      (write-frame-long/expression frame)))
+
+(define (write-frame-long/application frame)
+  (display "This frame is an application.")
+  (newline)
+  (if (frame-source frame)
+      (begin
+	(display "The corresponding expression is:")
+	(newline)
+	(display-source frame)
+	(newline)))
+  (display "The procedure being applied is: ")
+  (write (let ((procedure (frame-procedure frame)))
+	   (or (and (procedure? procedure)
+		    (procedure-name procedure))
+	       procedure)))
+  (newline)
+  (display "The procedure's arguments are")
+  (if (frame-evaluating-args? frame)
+      (display " being evaluated.")
+      (begin
+	(display ": ")
+	(write (frame-arguments frame))))
+  (newline))
+
+(define (display-source frame)
+  (let* ((source (frame-source frame))
+	 (copy (source-property source 'copy)))
+    (cond ((source-position source)
+	   => (lambda (p) (display-position p) (display ":\n"))))
+    (display "  ")
+    (write (or copy (unmemoize-expr source)))))
+
+(define (source-position source)
+  (let ((fname (source-property source 'filename))
+	(line (source-property source 'line))
+	(column (source-property source 'column)))
+    (and fname
+	 (list fname line column))))
+
+(define (display-position pos)
+  (format #t "~A:~D:~D" (car pos) (+ 1 (cadr pos)) (+ 1 (caddr pos))))
+
+(define (write-frame-long/expression frame)
+  (display "This frame is an evaluation.")
+  (newline)
+  (display "The expression being evaluated is:")
+  (newline)
+  (display-source frame)
+  (newline))
+
+(define (write-frame-args-long frame)
+  (if (frame-procedure? frame)
+      (let ((arguments (frame-arguments frame)))
+	(let ((n (length arguments)))
+	  (display "This frame has ")
+	  (write n)
+	  (display " argument")
+	  (if (not (= n 1))
+	      (display "s"))
+	  (write-char (if (null? arguments) #\. #\:))
+	  (newline))
+	(for-each (lambda (argument)
+		    (display "  ")
+		    (write argument)
+		    (newline))
+		  arguments))
+      (begin
+	(display "This frame is an evaluation frame; it has no arguments.")
+	(newline))))
+
+(define (write-chars char n)
+  (do ((i 0 (+ i 1)))
+      ((>= i n))
+    (write-char char)))

node-addon-lilypond/output/share/guile/1.8/ice-9/debugging/example-fns.scm

@@ -0,0 +1,17 @@
+(define-module (ice-9 debugging example-fns)
+  #:export (fact1 fact2 facti))
+
+(define (fact1 n)
+  (if (= n 0)
+      1
+      (* n (fact1 (- n 1)))))
+
+(define (facti n a)
+  (if (= n 0)
+      a
+      (facti (- n 1) (* a n))))
+
+(define (fact2 n)
+  (facti n 1))
+
+; Test: (fact2 3)

node-addon-lilypond/output/share/guile/1.8/ice-9/debugging/ice-9-debugger-extensions.scm

@@ -0,0 +1,173 @@
+
+(define-module (ice-9 debugging ice-9-debugger-extensions)
+  #:use-module (ice-9 debugger))
+
+;;; Upgrade the debugger state object so that it can carry a flag
+;;; indicating whether the debugging session is continuable.
+
+(cond ((string>=? (version) "1.7")
+       (use-modules (ice-9 debugger state))
+       (define-module (ice-9 debugger state)))
+      (else
+       (define-module (ice-9 debugger))))
+
+(set! state-rtd (make-record-type "debugger-state" '(stack index flags)))
+(set! state? (record-predicate state-rtd))
+(set! make-state
+  (let ((make-state-internal (record-constructor state-rtd
+						 '(stack index flags))))
+    (lambda (stack index . flags)
+      (make-state-internal stack index flags))))
+(set! state-stack (record-accessor state-rtd 'stack))
+(set! state-index (record-accessor state-rtd 'index))
+
+(define state-flags (record-accessor state-rtd 'flags))
+
+;;; Add commands that (ice-9 debugger) doesn't currently have, for
+;;; continuing or single stepping program execution.
+
+(cond ((string>=? (version) "1.7")
+       (use-modules (ice-9 debugger command-loop))
+       (define-module (ice-9 debugger command-loop)
+	 #:use-module (ice-9 debugger)
+	 #:use-module (ice-9 debugger state)
+	 #:use-module (ice-9 debugging traps))
+       (define new-define-command define-command)
+       (set! define-command
+	     (lambda (name argument-template documentation procedure)
+	       (new-define-command name argument-template procedure))))
+      (else
+       (define-module (ice-9 debugger))))
+
+(use-modules (ice-9 debugging steps)
+             (ice-9 debugging trace))
+
+(define (assert-continuable state)
+  ;; Check that debugger is in a state where `continuing' makes sense.
+  ;; If not, signal an error.
+  (or (memq #:continuable (state-flags state))
+      (user-error "This debug session is not continuable.")))
+
+(define (debugger:continue state)
+  "Tell the program being debugged to continue running.  (In fact this is
+the same as the @code{quit} command, because it exits the debugger
+command loop and so allows whatever code it was that invoked the
+debugger to continue.)"
+  (assert-continuable state)
+  (throw 'exit-debugger))
+
+(define (debugger:finish state)
+  "Continue until evaluation of the current frame is complete, and
+print the result obtained."
+  (assert-continuable state)
+  (at-exit (- (stack-length (state-stack state))
+	      (state-index state))
+	   (list trace-trap debug-trap))
+  (debugger:continue state))
+
+(define (debugger:step state n)
+  "Tell the debugged program to do @var{n} more steps from its current
+position.  One @dfn{step} means executing until the next frame entry
+or exit of any kind.  @var{n} defaults to 1."
+  (assert-continuable state)
+  (at-step debug-trap (or n 1))
+  (debugger:continue state))
+
+(define (debugger:next state n)
+  "Tell the debugged program to do @var{n} more steps from its current
+position, but only counting frame entries and exits where the
+corresponding source code comes from the same file as the current
+stack frame.  (See @ref{Step Traps} for the details of how this
+works.)  If the current stack frame has no source code, the effect of
+this command is the same as of @code{step}.  @var{n} defaults to 1."
+  (assert-continuable state)
+  (at-step debug-trap
+	   (or n 1)
+	   (frame-file-name (stack-ref (state-stack state)
+				       (state-index state)))
+	   (if (memq #:return (state-flags state))
+	       #f
+	       (- (stack-length (state-stack state)) (state-index state))))
+  (debugger:continue state))
+
+(define-command "continue" '()
+  "Continue program execution."
+  debugger:continue)
+
+(define-command "finish" '()
+  "Continue until evaluation of the current frame is complete, and
+print the result obtained."
+  debugger:finish)
+
+(define-command "step" '('optional exact-integer)
+  "Continue until entry to @var{n}th next frame."
+  debugger:step)
+
+(define-command "next" '('optional exact-integer)
+  "Continue until entry to @var{n}th next frame in same file."
+  debugger:next)
+
+;;; Export a couple of procedures for use by (ice-9 debugging trace).
+
+(cond ((string>=? (version) "1.7"))
+      (else
+       (define-module (ice-9 debugger))
+       (export write-frame-short/expression
+	       write-frame-short/application)))
+
+;;; Provide a `debug-trap' entry point in (ice-9 debugger).  This is
+;;; designed so that it can be called to explore the stack at a
+;;; breakpoint, and to single step from the breakpoint.
+
+(define-module (ice-9 debugger))
+
+(use-modules (ice-9 debugging traps))
+
+(define *not-yet-introduced* #t)
+
+(cond ((string>=? (version) "1.7"))
+      (else
+       (define (debugger-command-loop state)
+	 (read-and-dispatch-commands state (current-input-port)))))
+
+(define-public (debug-trap trap-context)
+  "Invoke the Guile debugger to explore the stack at the specified @var{trap}."
+  (start-stack 'debugger
+	       (let* ((stack (tc:stack trap-context))
+		      (flags1 (let ((trap-type (tc:type trap-context)))
+				(case trap-type
+				  ((#:return #:error)
+				   (list trap-type
+					 (tc:return-value trap-context)))
+				  (else
+				   (list trap-type)))))
+		      (flags (if (tc:continuation trap-context)
+				 (cons #:continuable flags1)
+				 flags1))
+		      (state (apply make-state stack 0 flags)))
+		 (if *not-yet-introduced*
+		     (let ((ssize (stack-length stack)))
+		       (display "This is the Guile debugger -- for help, type `help'.\n")
+		       (set! *not-yet-introduced* #f)
+		       (if (= ssize 1)
+			   (display "There is 1 frame on the stack.\n\n")
+			   (format #t "There are ~A frames on the stack.\n\n" ssize))))
+		 (write-state-short-with-source-location state)
+		 (debugger-command-loop state))))
+
+(define write-state-short-with-source-location
+  (cond ((string>=? (version) "1.7")
+	 write-state-short)
+	(else
+	 (lambda (state)
+	   (let* ((frame (stack-ref (state-stack state) (state-index state)))
+		  (source (frame-source frame))
+		  (position (and source (source-position source))))
+	     (format #t "Frame ~A at " (frame-number frame))
+	     (if position
+		 (display-position position)
+		 (display "unknown source location"))
+	     (newline)
+	     (write-char #\tab)
+	     (write-frame-short frame)
+	     (newline))))))

node-addon-lilypond/output/share/guile/1.8/ice-9/debugging/steps.scm

@@ -0,0 +1,106 @@
+;;;; (ice-9 debugging steps) -- stepping through code from the debugger
+
+;;; Copyright (C) 2002, 2004 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+(define-module (ice-9 debugging steps)
+  #:use-module (ice-9 debugging traps)
+  #:use-module (ice-9 and-let-star)
+  #:use-module (ice-9 debugger)
+  #:use-module (ice-9 optargs)
+  #:export (at-exit
+	    at-entry
+	    at-apply
+	    at-step
+	    at-next))
+
+;;; at-exit DEPTH BEHAVIOUR
+;;;
+;;; Install a behaviour to run when we exit the current frame.
+
+(define (at-exit depth behaviour)
+  (install-trap (make <exit-trap>
+		  #:depth depth
+		  #:single-shot #t
+		  #:behaviour behaviour)))
+
+;;; at-entry BEHAVIOUR [COUNT]
+;;;
+;;; Install a behaviour to run when we get to the COUNT'th next frame
+;;; entry.  COUNT defaults to 1.
+
+(define* (at-entry behaviour #:optional (count 1))
+  (install-trap (make <entry-trap>
+		  #:skip-count (- count 1)
+		  #:single-shot #t
+		  #:behaviour behaviour)))
+
+;;; at-apply BEHAVIOUR [COUNT]
+;;;
+;;; Install a behaviour to run when we get to the COUNT'th next
+;;; application.  COUNT defaults to 1.
+
+(define* (at-apply behaviour #:optional (count 1))
+  (install-trap (make <apply-trap>
+		  #:skip-count (- count 1)
+		  #:single-shot #t
+		  #:behaviour behaviour)))
+
+;;; at-step BEHAVIOUR [COUNT [FILENAME [DEPTH]]
+;;;
+;;; Install BEHAVIOUR to run on the COUNT'th next application, frame
+;;; entry or frame exit.  COUNT defaults to 1.  If FILENAME is
+;;; specified and not #f, only frames that begin in the named file are
+;;; counted.
+
+(define* (at-step behaviour #:optional (count 1) filename (depth 1000))
+  (install-trap (make <step-trap>
+		  #:file-name filename
+		  #:exit-depth depth
+		  #:skip-count (- count 1)
+		  #:single-shot #t
+		  #:behaviour behaviour)))
+
+;;  (or count (set! count 1))
+;;  (letrec ((proc (lambda (trap-context)
+;;		   ;; Behaviour whenever we enter or exit a frame.
+;;		   (set! count (- count 1))
+;;		   (if (= count 0)
+;;		       (begin
+;;			 (remove-enter-frame-hook! step)
+;;			 (remove-apply-frame-hook! step)
+;;			 (behaviour trap-context)))))
+;;	   (step (lambda (trap-context)
+;;		   ;; Behaviour on frame entry: both execute the above
+;;		   ;; and install it as an exit hook.
+;;		   (if (or (not filename)
+;;			   (equal? (frame-file-name (tc:frame trap-context))
+;;                                   filename))
+;;		       (begin
+;;			 (proc trap-context)
+;;			 (at-exit (tc:depth trap-context) proc))))))
+;;    (at-exit depth proc)
+;;    (add-enter-frame-hook! step)
+;;    (add-apply-frame-hook! step)))
+
+;;; at-next BEHAVIOUR [COUNT]
+;;;
+;;; Install a behaviour to run when we get to the COUNT'th next frame
+;;; entry in the same source file as the current location.  COUNT
+;;; defaults to 1.  If the current location has no filename, fall back
+;;; silently to `at-entry' behaviour.
+
+;;; (ice-9 debugging steps) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugging/trace.scm

@@ -0,0 +1,157 @@
+;;;; (ice-9 debugging trace) -- breakpoint trace behaviour
+
+;;; Copyright (C) 2002 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+(define-module (ice-9 debugging trace)
+  #:use-module (ice-9 debug)
+  #:use-module (ice-9 debugger)
+  #:use-module (ice-9 debugging ice-9-debugger-extensions)
+  #:use-module (ice-9 debugging steps)
+  #:use-module (ice-9 debugging traps)
+  #:export (trace-trap
+	    trace-port
+	    set-trace-layout
+            trace/pid
+            trace/stack-id
+            trace/stack-depth
+            trace/stack-real-depth
+            trace/stack
+            trace/source-file-name
+            trace/source-line
+            trace/source-column
+            trace/source
+            trace/type
+            trace/real?
+            trace/info
+	    trace-at-exit
+	    trace-until-exit))
+
+(cond ((string>=? (version) "1.7")
+       (use-modules (ice-9 debugger utils))))
+
+(define trace-format-string #f)
+(define trace-arg-procs #f)
+
+(define (set-trace-layout format-string . arg-procs)
+  (set! trace-format-string format-string)
+  (set! trace-arg-procs arg-procs))
+
+(define (trace/pid trap-context)
+  (getpid))
+
+(define (trace/stack-id trap-context)
+  (stack-id (tc:stack trap-context)))
+
+(define (trace/stack-depth trap-context)
+  (tc:depth trap-context))
+
+(define (trace/stack-real-depth trap-context)
+  (tc:real-depth trap-context))
+
+(define (trace/stack trap-context)
+  (format #f "~a:~a+~a"
+	  (stack-id (tc:stack trap-context))
+	  (tc:real-depth trap-context)
+	  (- (tc:depth trap-context) (tc:real-depth trap-context))))
+
+(define (trace/source-file-name trap-context)
+  (cond ((frame->source-position (tc:frame trap-context)) => car)
+	(else "")))
+
+(define (trace/source-line trap-context)
+  (cond ((frame->source-position (tc:frame trap-context)) => cadr)
+	(else 0)))
+
+(define (trace/source-column trap-context)
+  (cond ((frame->source-position (tc:frame trap-context)) => caddr)
+	(else 0)))
+
+(define (trace/source trap-context)
+  (cond ((frame->source-position (tc:frame trap-context))
+	 =>
+	 (lambda (pos)
+	   (format #f "~a:~a:~a" (car pos) (cadr pos) (caddr pos))))
+	(else "")))
+
+(define (trace/type trap-context)
+  (case (tc:type trap-context)
+    ((#:application) "APP")
+    ((#:evaluation) "EVA")
+    ((#:return) "RET")
+    ((#:error) "ERR")
+    (else "???")))
+
+(define (trace/real? trap-context)
+  (if (frame-real? (tc:frame trap-context)) " " "t"))
+
+(define (trace/info trap-context)
+  (with-output-to-string
+    (lambda ()
+      (if (memq (tc:type trap-context) '(#:application #:evaluation))
+	  ((if (tc:expression trap-context)
+	       write-frame-short/expression
+	       write-frame-short/application) (tc:frame trap-context))
+	  (begin
+	    (display "=>")
+	    (write (tc:return-value trap-context)))))))
+
+(set-trace-layout "|~3@a: ~a\n" trace/stack-real-depth trace/info)
+
+;;; trace-trap
+;;;
+;;; Trace the current location, and install a hook to trace the return
+;;; value when we exit the current frame.
+
+(define (trace-trap trap-context)
+  (apply format
+	 (trace-port)
+	 trace-format-string
+	 (map (lambda (arg-proc)
+		(arg-proc trap-context))
+	      trace-arg-procs)))
+
+(set! (behaviour-ordering trace-trap) 50)
+
+;;; trace-port
+;;;
+;;; The port to which trace information is printed.
+
+(define trace-port
+  (let ((port (current-output-port)))
+    (make-procedure-with-setter
+     (lambda () port)
+     (lambda (new) (set! port new)))))
+
+;;; trace-at-exit
+;;;
+;;; Trace return value on exit from the current frame.
+
+(define (trace-at-exit trap-context)
+  (at-exit (tc:depth trap-context) trace-trap))
+
+;;; trace-until-exit
+;;;
+;;; Trace absolutely everything until exit from the current frame.
+
+(define (trace-until-exit trap-context)
+  (let ((step-trap (make <step-trap> #:behaviour trace-trap)))
+    (install-trap step-trap)
+    (at-exit (tc:depth trap-context)
+	     (lambda (trap-context)
+	       (uninstall-trap step-trap)))))
+
+;;; (ice-9 debugging trace) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugging/traps.scm

@@ -0,0 +1,1037 @@
+;;;; (ice-9 debugging traps) -- abstraction of libguile's traps interface
+
+;;; Copyright (C) 2002, 2004 Free Software Foundation, Inc.
+;;; Copyright (C) 2005 Neil Jerram
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+;;; This module provides an abstraction around Guile's low level trap
+;;; handler interface; its aim is to make the low level trap mechanism
+;;; shareable between the debugger and other applications, and to
+;;; insulate the rest of the debugger code a bit from changes that may
+;;; occur in the low level trap interface in future.
+
+(define-module (ice-9 debugging traps)
+  #:use-module (ice-9 regex)
+  #:use-module (oop goops)
+  #:use-module (oop goops describe)
+  #:use-module (ice-9 debugging trc)
+  #:use-module (srfi srfi-1)
+  #:use-module (srfi srfi-2)
+  #:export (tc:type
+            tc:continuation
+            tc:expression
+            tc:return-value
+            tc:stack
+            tc:frame
+            tc:depth
+            tc:real-depth
+            tc:exit-depth
+	    tc:fired-traps
+	    ;; Interface for users of <trap> subclasses defined in
+	    ;; this module.
+            add-trapped-stack-id!
+	    remove-trapped-stack-id!
+	    <procedure-trap>
+	    <exit-trap>
+	    <entry-trap>
+	    <apply-trap>
+	    <step-trap>
+	    <source-trap>
+	    <location-trap>
+	    install-trap
+	    uninstall-trap
+            all-traps
+            get-trap
+	    list-traps
+	    trap-ordering
+            behaviour-ordering
+	    throw->trap-context
+	    on-lazy-handler-dispatch
+	    ;; Interface for authors of new <trap> subclasses.
+	    <trap-context>
+	    <trap>
+	    trap->behaviour
+	    trap-runnable?
+	    install-apply-frame-trap
+	    install-breakpoint-trap
+	    install-enter-frame-trap
+	    install-exit-frame-trap
+	    install-trace-trap
+	    uninstall-apply-frame-trap
+	    uninstall-breakpoint-trap
+	    uninstall-enter-frame-trap
+	    uninstall-exit-frame-trap
+	    uninstall-trace-trap
+	    frame->source-position
+	    frame-file-name
+	    without-traps
+            guile-trap-features)
+  #:re-export (make)
+  #:export-syntax (trap-here))
+
+;; How to debug the debugging infrastructure, when needed.  Grep for
+;; "(trc " to find other symbols that can be passed to trc-add.
+;; (trc-add 'after-gc-hook)
+
+;; In Guile 1.7 onwards, weak-vector and friends are provided by the
+;; (ice-9 weak-vector) module.
+(cond ((string>=? (version) "1.7")
+       (use-modules (ice-9 weak-vector))))
+
+;;; The current low level traps interface is as follows.
+;;;
+;;; All trap handlers are subject to SCM_TRAPS_P, which is controlled
+;;; by the `traps' setting of `(evaluator-traps-interface)' but also
+;;; (and more relevant in most cases) by the `with-traps' procedure.
+;;; Basically, `with-traps' sets SCM_TRAPS_P to 1 during execution of
+;;; its thunk parameter.
+;;;
+;;; Note that all trap handlers are called with SCM_TRAPS_P set to 0
+;;; for the duration of the call, to avoid nasty recursive trapping
+;;; loops.  If a trap handler knows what it is doing, it can override
+;;; this by `(trap-enable traps)'.
+;;;
+;;; The apply-frame handler is called when Guile is about to perform
+;;; an application if EITHER the `apply-frame' evaluator trap option
+;;; is set, OR the `trace' debug option is set and the procedure to
+;;; apply has its `trace' procedure property set.  The arguments
+;;; passed are:
+;;;
+;;; - the symbol 'apply-frame
+;;;
+;;; - a continuation or debug object describing the current stack
+;;;
+;;; - a boolean indicating whether the application is tail-recursive.
+;;;
+;;; The enter-frame handler is called when the evaluator begins a new
+;;; evaluation frame if EITHER the `enter-frame' evaluator trap option
+;;; is set, OR the `breakpoints' debug option is set and the code to
+;;; be evaluated has its `breakpoint' source property set.  The
+;;; arguments passed are:
+;;;
+;;; - the symbol 'enter-frame
+;;;
+;;; - a continuation or debug object describing the current stack
+;;;
+;;; - a boolean indicating whether the application is tail-recursive.
+;;;
+;;; - an unmemoized copy of the expression to be evaluated.
+;;;
+;;; If the `enter-frame' evaluator trap option is set, the enter-frame
+;;; handler is also called when about to perform an application in
+;;; SCM_APPLY, immediately before possibly calling the apply-frame
+;;; handler.  (I don't totally understand this.)  In this case, the
+;;; arguments passed are:
+;;;
+;;; - the symbol 'enter-frame
+;;;
+;;; - a continuation or debug object describing the current stack.
+;;;
+;;; The exit-frame handler is called when Guile exits an evaluation
+;;; frame (in SCM_CEVAL) or an application frame (in SCM_APPLY), if
+;;; EITHER the `exit-frame' evaluator trap option is set, OR the
+;;; `trace' debug option is set and the frame is marked as having been
+;;; traced.  The frame will be marked as having been traced if the
+;;; apply-frame handler was called for this frame.  (This is trickier
+;;; than it sounds because of tail recursion: the same debug frame
+;;; could have been used for multiple applications, only some of which
+;;; were traced - I think.)  The arguments passed are:
+;;;
+;;; - the symbol 'exit-frame
+;;;
+;;; - a continuation or debug object describing the current stack
+;;;
+;;; - the result of the evaluation or application.
+
+;;; {Trap Context}
+;;;
+;;; A trap context is a GOOPS object that encapsulates all the useful
+;;; information about a particular trap.  Encapsulating this
+;;; information in a single object also allows us:
+;;;
+;;; - to defer the calculation of information that is time-consuming
+;;; to calculate, such as the stack, and to cache such information so
+;;; that it is only ever calculated once per trap
+;;;
+;;; - to pass all interesting information to trap behaviour procedures
+;;; in a single parameter, which (i) is convenient and (ii) makes for
+;;; a more future-proof interface.
+;;;
+;;; It also allows us - where very carefully documented! - to pass
+;;; information from one behaviour procedure to another.
+
+(define-class <trap-context> ()
+  ;; Information provided directly by the trap calls from the
+  ;; evaluator.  The "type" slot holds a keyword indicating the type
+  ;; of the trap: one of #:evaluation, #:application, #:return,
+  ;; #:error.
+  (type #:getter tc:type
+        #:init-keyword #:type)
+  ;; The "continuation" slot holds the continuation (or debug object,
+  ;; if "cheap" traps are enabled, which is the default) at the point
+  ;; of the trap.  For an error trap it is #f.
+  (continuation #:getter tc:continuation
+                #:init-keyword #:continuation)
+  ;; The "expression" slot holds the source code expression, for an
+  ;; evaluation trap.
+  (expression #:getter tc:expression
+              #:init-keyword #:expression
+              #:init-value #f)
+  ;; The "return-value" slot holds the return value, for a return
+  ;; trap, or the error args, for an error trap.
+  (return-value #:getter tc:return-value
+                #:init-keyword #:return-value
+                #:init-value #f)
+  ;; The list of trap objects which fired in this trap context.
+  (fired-traps #:getter tc:fired-traps
+	       #:init-value '())
+  ;; The set of symbols which, if one of them is set in the CAR of the
+  ;; handler-return-value slot, will cause the CDR of that slot to
+  ;; have an effect.
+  (handler-return-syms #:init-value '())
+  ;; The value which the trap handler should return to the evaluator.
+  (handler-return-value #:init-value #f)
+  ;; Calculated and cached information.  "stack" is the stack
+  ;; (computed from the continuation (or debug object) by make-stack,
+  ;; or else (in the case of an error trap) by (make-stack #t ...).
+  (stack #:init-value #f)
+  (frame #:init-value #f)
+  (depth #:init-value #f)
+  (real-depth #:init-value #f)
+  (exit-depth #:init-value #f))
+
+(define-method (tc:stack (ctx <trap-context>))
+  (or (slot-ref ctx 'stack)
+      (let ((stack (make-stack (tc:continuation ctx))))
+        (slot-set! ctx 'stack stack)
+        stack)))
+
+(define-method (tc:frame (ctx <trap-context>))
+  (or (slot-ref ctx 'frame)
+      (let ((frame (cond ((tc:continuation ctx) => last-stack-frame)
+			 (else (stack-ref (tc:stack ctx) 0)))))
+        (slot-set! ctx 'frame frame)
+        frame)))
+
+(define-method (tc:depth (ctx <trap-context>))
+  (or (slot-ref ctx 'depth)
+      (let ((depth (stack-length (tc:stack ctx))))
+        (slot-set! ctx 'depth depth)
+        depth)))
+
+(define-method (tc:real-depth (ctx <trap-context>))
+  (or (slot-ref ctx 'real-depth)
+      (let* ((stack (tc:stack ctx))
+	     (real-depth (apply +
+				(map (lambda (i)
+				       (if (frame-real? (stack-ref stack i))
+					   1
+					   0))
+				     (iota (tc:depth ctx))))))
+        (slot-set! ctx 'real-depth real-depth)
+        real-depth)))
+
+(define-method (tc:exit-depth (ctx <trap-context>))
+  (or (slot-ref ctx 'exit-depth)
+      (let* ((stack (tc:stack ctx))
+	     (depth (tc:depth ctx))
+	     (exit-depth (let loop ((exit-depth depth))
+			   (if (or (zero? exit-depth)
+				   (frame-real? (stack-ref stack
+							   (- depth
+							      exit-depth))))
+			       exit-depth
+			       (loop (- exit-depth 1))))))
+	(slot-set! ctx 'exit-depth exit-depth)
+        exit-depth)))
+
+;;; {Stack IDs}
+;;;
+;;; Mechanism for limiting trapping to contexts whose stack ID matches
+;;; one of a registered set.  The default is for traps to fire
+;;; regardless of stack ID.
+
+(define trapped-stack-ids (list #t))
+(define all-stack-ids-trapped? #t)
+
+(define (add-trapped-stack-id! id)
+  "Add ID to the set of stack ids for which traps are active.
+If `#t' is in this set, traps are active regardless of stack context.
+To remove ID again, use `remove-trapped-stack-id!'.  If you add the
+same ID twice using `add-trapped-stack-id!', you will need to remove
+it twice."
+  (set! trapped-stack-ids (cons id trapped-stack-ids))
+  (set! all-stack-ids-trapped? (memq #t trapped-stack-ids)))
+
+(define (remove-trapped-stack-id! id)
+  "Remove ID from the set of stack ids for which traps are active."
+  (set! trapped-stack-ids (delq1! id trapped-stack-ids))
+  (set! all-stack-ids-trapped? (memq #t trapped-stack-ids)))
+
+(define (trap-here? cont)
+  ;; Return true if the stack id of the specified continuation (or
+  ;; debug object) is in the set that we should trap for; otherwise
+  ;; false.
+  (or all-stack-ids-trapped?
+      (memq (stack-id cont) trapped-stack-ids)))
+
+;;; {Global State}
+;;;
+;;; Variables tracking registered handlers, relevant procedures, and
+;;; what's turned on as regards the evaluator's debugging options.
+
+(define enter-frame-traps '())
+(define apply-frame-traps '())
+(define exit-frame-traps '())
+(define breakpoint-traps '())
+(define trace-traps '())
+
+(define (non-null? hook)
+  (not (null? hook)))
+
+;; The low level frame handlers must all be initialized to something
+;; harmless.  Otherwise we hit a problem immediately when trying to
+;; enable one of these handlers.
+(trap-set! enter-frame-handler noop)
+(trap-set! apply-frame-handler noop)
+(trap-set! exit-frame-handler noop)
+
+(define set-debug-and-trap-options
+  (let ((dopts (debug-options))
+	(topts (evaluator-traps-interface))
+	(setting (lambda (key opts)
+		   (let ((l (memq key opts)))
+		     (and l
+			  (not (null? (cdr l)))
+			  (cadr l)))))
+	(debug-set-boolean! (lambda (key value)
+			      ((if value debug-enable debug-disable) key)))
+	(trap-set-boolean! (lambda (key value)
+			     ((if value trap-enable trap-disable) key))))
+    (let ((save-debug (memq 'debug dopts))
+	  (save-trace (memq 'trace dopts))
+	  (save-breakpoints (memq 'breakpoints dopts))
+	  (save-enter-frame (memq 'enter-frame topts))
+	  (save-apply-frame (memq 'apply-frame topts))
+	  (save-exit-frame (memq 'exit-frame topts))
+	  (save-enter-frame-handler (setting 'enter-frame-handler topts))
+	  (save-apply-frame-handler (setting 'apply-frame-handler topts))
+	  (save-exit-frame-handler (setting 'exit-frame-handler topts)))
+      (lambda ()
+	(let ((need-trace (non-null? trace-traps))
+	      (need-breakpoints (non-null? breakpoint-traps))
+	      (need-enter-frame (non-null? enter-frame-traps))
+	      (need-apply-frame (non-null? apply-frame-traps))
+	      (need-exit-frame (non-null? exit-frame-traps)))
+	  (debug-set-boolean! 'debug
+			      (or need-trace
+				  need-breakpoints
+				  need-enter-frame
+				  need-apply-frame
+				  need-exit-frame
+				  save-debug))
+	  (debug-set-boolean! 'trace
+			      (or need-trace
+				  save-trace))
+	  (debug-set-boolean! 'breakpoints
+			      (or need-breakpoints
+				  save-breakpoints))
+	  (trap-set-boolean! 'enter-frame
+			     (or need-enter-frame
+				 save-enter-frame))
+	  (trap-set-boolean! 'apply-frame
+			     (or need-apply-frame
+				 save-apply-frame))
+	  (trap-set-boolean! 'exit-frame
+			     (or need-exit-frame
+				 save-exit-frame))
+	  (trap-set! enter-frame-handler
+		     (cond ((or need-breakpoints
+				need-enter-frame)
+			    enter-frame-handler)
+			   (else save-enter-frame-handler)))
+	  (trap-set! apply-frame-handler
+		     (cond ((or need-trace
+				need-apply-frame)
+			    apply-frame-handler)
+			   (else save-apply-frame-handler)))
+	  (trap-set! exit-frame-handler
+		     (cond ((or need-exit-frame)
+			    exit-frame-handler)
+			   (else save-exit-frame-handler))))
+	;;(write (evaluator-traps-interface))
+	*unspecified*))))
+
+(define (enter-frame-handler key cont . args)
+  ;; For a non-application entry, ARGS is (TAIL? EXP), where EXP is an
+  ;; unmemoized copy of the source expression.  For an application
+  ;; entry, ARGS is empty.
+  (if (trap-here? cont)
+      (let* ((application-entry? (null? args))
+             (trap-context (make <trap-context>
+                             #:type #:evaluation
+                             #:continuation cont
+                             #:expression (if application-entry?
+                                              #f
+                                              (cadr args)))))
+	(trc 'enter-frame-handler)
+	(if (and (not application-entry?)
+                 (memq 'tweaking guile-trap-features))
+	    (slot-set! trap-context 'handler-return-syms '(instead)))
+        (run-traps (if application-entry?
+		       enter-frame-traps
+		       (append enter-frame-traps breakpoint-traps))
+		   trap-context)
+	(slot-ref trap-context 'handler-return-value))))
+
+(define (apply-frame-handler key cont tail?)
+  (if (trap-here? cont)
+      (let ((trap-context (make <trap-context>
+                            #:type #:application
+                            #:continuation cont)))
+	(trc 'apply-frame-handler tail?)
+        (run-traps (append apply-frame-traps trace-traps) trap-context)
+	(slot-ref trap-context 'handler-return-value))))
+
+(define (exit-frame-handler key cont retval)
+  (if (trap-here? cont)
+      (let ((trap-context (make <trap-context>
+                            #:type #:return
+                            #:continuation cont
+                            #:return-value retval)))
+	(trc 'exit-frame-handler retval (tc:depth trap-context))
+	(if (memq 'tweaking guile-trap-features)
+            (slot-set! trap-context 'handler-return-syms '(instead)))
+        (run-traps exit-frame-traps trap-context)
+	(slot-ref trap-context 'handler-return-value))))
+
+(define-macro (trap-installer trap-list)
+  `(lambda (trap)
+     (set! ,trap-list (cons trap ,trap-list))
+     (set-debug-and-trap-options)))
+
+(define install-enter-frame-trap (trap-installer enter-frame-traps))
+(define install-apply-frame-trap (trap-installer apply-frame-traps))
+(define install-exit-frame-trap (trap-installer exit-frame-traps))
+(define install-breakpoint-trap (trap-installer breakpoint-traps))
+(define install-trace-trap (trap-installer trace-traps))
+
+(define-macro (trap-uninstaller trap-list)
+  `(lambda (trap)
+     (or (memq trap ,trap-list)
+         (error "Trap list does not include the specified trap"))
+     (set! ,trap-list (delq1! trap ,trap-list))
+     (set-debug-and-trap-options)))
+
+(define uninstall-enter-frame-trap (trap-uninstaller enter-frame-traps))
+(define uninstall-apply-frame-trap (trap-uninstaller apply-frame-traps))
+(define uninstall-exit-frame-trap (trap-uninstaller exit-frame-traps))
+(define uninstall-breakpoint-trap (trap-uninstaller breakpoint-traps))
+(define uninstall-trace-trap (trap-uninstaller trace-traps))
+
+(define trap-ordering (make-object-property))
+(define behaviour-ordering (make-object-property))
+
+(define (run-traps traps trap-context)
+  (let ((behaviours (apply append
+			   (map (lambda (trap)
+				  (trap->behaviour trap trap-context))
+				(sort traps
+				      (lambda (t1 t2)
+					(< (or (trap-ordering t1) 0)
+					   (or (trap-ordering t2) 0))))))))
+    (for-each (lambda (proc)
+		(proc trap-context))
+	      (sort (delete-duplicates behaviours)
+		    (lambda (b1 b2)
+                    (< (or (behaviour-ordering b1) 0)
+                       (or (behaviour-ordering b2) 0)))))))
+
+;;; {Pseudo-Traps for Non-Trap Events}
+
+;;; Once there is a body of code to do with responding to (debugging,
+;;; tracing, etc.) traps, it makes sense to be able to leverage that
+;;; same code for certain events that are trap-like, but not actually
+;;; traps in the sense of the calls made by libguile's evaluator.
+
+;;; The main example of this is when an error is signalled.  Guile
+;;; doesn't yet have a 100% reliable way of hooking into errors, but
+;;; in practice most errors go through a lazy-catch whose handler is
+;;; lazy-handler-dispatch (defined in ice-9/boot-9.scm), which in turn
+;;; calls default-lazy-handler.  So we can present most errors as
+;;; pseudo-traps by modifying default-lazy-handler.
+
+(define default-default-lazy-handler default-lazy-handler)
+
+(define (throw->trap-context key args . stack-args)
+  (let ((ctx (make <trap-context>
+	       #:type #:error
+	       #:continuation #f
+	       #:return-value (cons key args))))
+    (slot-set! ctx 'stack
+	       (let ((caller-stack (and (= (length stack-args) 1)
+					(car stack-args))))
+		 (if (stack? caller-stack)
+		     caller-stack
+		     (apply make-stack #t stack-args))))
+    ctx))
+
+(define (on-lazy-handler-dispatch behaviour . ignored-keys)
+  (set! default-lazy-handler
+	(if behaviour
+	    (lambda (key . args)
+	      (or (memq key ignored-keys)
+		  (behaviour (throw->trap-context key
+						  args
+						  lazy-handler-dispatch)))
+	      (apply default-default-lazy-handler key args))
+	    default-default-lazy-handler)))
+
+;;; {Trap Classes}
+
+;;; Class: <trap>
+;;;
+;;; <trap> is the base class for traps.  Any actual trap should be an
+;;; instance of a class derived from <trap>, not of <trap> itself,
+;;; because there is no base class method for the install-trap,
+;;; trap-runnable? and uninstall-trap GFs.
+(define-class <trap> ()
+  ;; "number" slot: the number of this trap (assigned automatically).
+  (number)
+  ;; "installed" slot: whether this trap is installed.
+  (installed #:init-value #f)
+  ;; "condition" slot: if non-#f, this is a thunk which is called when
+  ;; the trap fires, to determine whether trap processing should
+  ;; proceed any further.
+  (condition #:init-value #f #:init-keyword #:condition)
+  ;; "skip-count" slot: a count of valid (after "condition"
+  ;; processing) firings of this trap to skip.
+  (skip-count #:init-value 0 #:init-keyword #:skip-count)
+  ;; "single-shot" slot: if non-#f, this trap is removed after it has
+  ;; successfully fired (after "condition" and "skip-count"
+  ;; processing) for the first time.
+  (single-shot #:init-value #f #:init-keyword #:single-shot)
+  ;; "behaviour" slot: procedure or list of procedures to call
+  ;; (passing the trap context as parameter) if we finally decide
+  ;; (after "condition" and "skip-count" processing) to run this
+  ;; trap's behaviour.
+  (behaviour #:init-value '() #:init-keyword #:behaviour)
+  ;; "repeat-identical-behaviour" slot: normally, if multiple <trap>
+  ;; objects are triggered by the same low level trap, and they
+  ;; request the same behaviour, it's only useful to do that behaviour
+  ;; once (per low level trap); so by default multiple requests for
+  ;; the same behaviour are coalesced.  If this slot is non-#f, the
+  ;; contents of the "behaviour" slot are uniquified so that they
+  ;; avoid being coalesced in this way.
+  (repeat-identical-behaviour #:init-value #f
+			      #:init-keyword #:repeat-identical-behaviour)
+  ;; "observer" slot: this is a procedure that is called with one
+  ;; EVENT argument when the trap status changes in certain
+  ;; interesting ways, currently the following.  (1) When the trap is
+  ;; uninstalled because of the target becoming inaccessible; EVENT in
+  ;; this case is 'target-gone.
+  (observer #:init-value #f #:init-keyword #:observer))
+
+(define last-assigned-trap-number 0)
+(define all-traps (make-weak-value-hash-table 7))
+
+(define-method (initialize (trap <trap>) initargs)
+  (next-method)
+  ;; Assign a trap number, and store in the hash of all traps.
+  (set! last-assigned-trap-number (+ last-assigned-trap-number 1))
+  (slot-set! trap 'number last-assigned-trap-number)
+  (hash-set! all-traps last-assigned-trap-number trap)
+  ;; Listify the behaviour slot, if not a list already.
+  (let ((behaviour (slot-ref trap 'behaviour)))
+    (if (procedure? behaviour)
+	(slot-set! trap 'behaviour (list behaviour)))))
+
+(define-generic install-trap)		; provided mostly by subclasses
+(define-generic uninstall-trap)		; provided mostly by subclasses
+(define-generic trap->behaviour)	; provided by <trap>
+(define-generic trap-runnable?)		; provided by subclasses
+
+(define-method (install-trap (trap <trap>))
+  (if (slot-ref trap 'installed)
+      (error "Trap is already installed"))
+  (slot-set! trap 'installed #t))
+
+(define-method (uninstall-trap (trap <trap>))
+  (or (slot-ref trap 'installed)
+      (error "Trap is not installed"))
+  (slot-set! trap 'installed #f))
+
+;;; uniquify-behaviour
+;;;
+;;; Uniquify BEHAVIOUR by wrapping it in a new lambda.
+(define (uniquify-behaviour behaviour)
+  (lambda (trap-context)
+    (behaviour trap-context)))
+
+;;; trap->behaviour
+;;;
+;;; If TRAP is runnable, given TRAP-CONTEXT, return a list of
+;;; behaviour procs to call with TRAP-CONTEXT as a parameter.
+;;; Otherwise return the empty list.
+(define-method (trap->behaviour (trap <trap>) (trap-context <trap-context>))
+  (if (and
+       ;; Check that the trap is runnable.  Runnability is implemented
+       ;; by the subclass and allows us to check, for example, that
+       ;; the procedure being applied in an apply-frame trap matches
+       ;; this trap's procedure.
+       (trap-runnable? trap trap-context)
+       ;; Check the additional condition, if specified.
+       (let ((condition (slot-ref trap 'condition)))
+	 (or (not condition)
+	     ((condition))))
+       ;; Check for a skip count.
+       (let ((skip-count (slot-ref trap 'skip-count)))
+	 (if (zero? skip-count)
+	     #t
+	     (begin
+	       (slot-set! trap 'skip-count (- skip-count 1))
+	       #f))))
+      ;; All checks passed, so we will return the contents of this
+      ;; trap's behaviour slot.
+      (begin
+	;; First, though, remove this trap if its single-shot slot
+	;; indicates that it should fire only once.
+	(if (slot-ref trap 'single-shot)
+	    (uninstall-trap trap))
+	;; Add this trap object to the context's list of traps which
+	;; fired here.
+	(slot-set! trap-context 'fired-traps
+		   (cons trap (tc:fired-traps trap-context)))
+	;; Return trap behaviour, uniquified if necessary.
+	(if (slot-ref trap 'repeat-identical-behaviour)
+	    (map uniquify-behaviour (slot-ref trap 'behaviour))
+	    (slot-ref trap 'behaviour)))
+      '()))
+
+;;; Class: <procedure-trap>
+;;;
+;;; An installed instance of <procedure-trap> triggers on invocation
+;;; of a specific procedure.
+(define-class <procedure-trap> (<trap>)
+  ;; "procedure" slot: the procedure to trap on.  This is implemented
+  ;; virtually, using the following weak vector slot, so as to avoid
+  ;; this trap preventing the GC of the target procedure.
+  (procedure #:init-keyword #:procedure
+	     #:allocation #:virtual
+	     #:slot-ref
+	     (lambda (trap)
+	       (vector-ref (slot-ref trap 'procedure-wv) 0))
+	     #:slot-set!
+	     (lambda (trap proc)
+	       (if (slot-bound? trap 'procedure-wv)
+		   (vector-set! (slot-ref trap 'procedure-wv) 0 proc)
+		   (slot-set! trap 'procedure-wv (weak-vector proc)))))
+  (procedure-wv))
+
+;; Customization of the initialize method: set up to handle what
+;; should happen when the procedure is GC'd.
+(define-method (initialize (trap <procedure-trap>) initargs)
+  (next-method)
+  (let* ((proc (slot-ref trap 'procedure))
+	 (existing-traps (volatile-target-traps proc)))
+    ;; If this is the target's first trap, give the target procedure
+    ;; to the volatile-target-guardian, so we can find out if it
+    ;; becomes inaccessible.
+    (or existing-traps (volatile-target-guardian proc))
+    ;; Add this trap to the target procedure's list of traps.
+    (set! (volatile-target-traps proc)
+	  (cons trap (or existing-traps '())))))
+
+(define procedure-trace-count (make-object-property))
+
+(define-method (install-trap (trap <procedure-trap>))
+  (next-method)
+  (let* ((proc (slot-ref trap 'procedure))
+         (trace-count (or (procedure-trace-count proc) 0)))
+    (set-procedure-property! proc 'trace #t)
+    (set! (procedure-trace-count proc) (+ trace-count 1)))
+  (install-trace-trap trap))
+
+(define-method (uninstall-trap (trap <procedure-trap>))
+  (next-method)
+  (let* ((proc (slot-ref trap 'procedure))
+         (trace-count (or (procedure-trace-count proc) 0)))
+    (if (= trace-count 1)
+        (set-procedure-property! proc 'trace #f))
+    (set! (procedure-trace-count proc) (- trace-count 1)))
+  (uninstall-trace-trap trap))
+
+(define-method (trap-runnable? (trap <procedure-trap>)
+			       (trap-context <trap-context>))
+  (eq? (slot-ref trap 'procedure)
+       (frame-procedure (tc:frame trap-context))))
+
+;;; Class: <exit-trap>
+;;;
+;;; An installed instance of <exit-trap> triggers on stack frame exit
+;;; past a specified stack depth.
+(define-class <exit-trap> (<trap>)
+  ;; "depth" slot: the reference depth for the trap.
+  (depth #:init-keyword #:depth))
+
+(define-method (install-trap (trap <exit-trap>))
+  (next-method)
+  (install-exit-frame-trap trap))
+
+(define-method (uninstall-trap (trap <exit-trap>))
+  (next-method)
+  (uninstall-exit-frame-trap trap))
+
+(define-method (trap-runnable? (trap <exit-trap>)
+			       (trap-context <trap-context>))
+  (<= (tc:exit-depth trap-context)
+      (slot-ref trap 'depth)))
+
+;;; Class: <entry-trap>
+;;;
+;;; An installed instance of <entry-trap> triggers on any frame entry.
+(define-class <entry-trap> (<trap>))
+
+(define-method (install-trap (trap <entry-trap>))
+  (next-method)
+  (install-enter-frame-trap trap))
+
+(define-method (uninstall-trap (trap <entry-trap>))
+  (next-method)
+  (uninstall-enter-frame-trap trap))
+
+(define-method (trap-runnable? (trap <entry-trap>)
+			       (trap-context <trap-context>))
+  #t)
+
+;;; Class: <apply-trap>
+;;;
+;;; An installed instance of <apply-trap> triggers on any procedure
+;;; application.
+(define-class <apply-trap> (<trap>))
+
+(define-method (install-trap (trap <apply-trap>))
+  (next-method)
+  (install-apply-frame-trap trap))
+
+(define-method (uninstall-trap (trap <apply-trap>))
+  (next-method)
+  (uninstall-apply-frame-trap trap))
+
+(define-method (trap-runnable? (trap <apply-trap>)
+			       (trap-context <trap-context>))
+  #t)
+
+;;; Class: <step-trap>
+;;;
+;;; An installed instance of <step-trap> triggers on the next frame
+;;; entry, exit or application, optionally with source location inside
+;;; a specified file.
+(define-class <step-trap> (<exit-trap>)
+  ;; "file-name" slot: if non-#f, indicates that this trap should
+  ;; trigger only for steps in source code from the specified file.
+  (file-name #:init-value #f #:init-keyword #:file-name)
+  ;; "exit-depth" slot: when non-#f, indicates that the next step may
+  ;; be a frame exit past this depth; otherwise, indicates that the
+  ;; next step must be an application or a frame entry.
+  (exit-depth #:init-value #f #:init-keyword #:exit-depth))
+
+(define-method (initialize (trap <step-trap>) initargs)
+  (next-method)
+  (slot-set! trap 'depth (slot-ref trap 'exit-depth)))
+
+(define-method (install-trap (trap <step-trap>))
+  (next-method)
+  (install-enter-frame-trap trap)
+  (install-apply-frame-trap trap))
+
+(define-method (uninstall-trap (trap <step-trap>))
+  (next-method)
+  (uninstall-enter-frame-trap trap)
+  (uninstall-apply-frame-trap trap))
+
+(define-method (trap-runnable? (trap <step-trap>)
+			       (trap-context <trap-context>))
+  (if (eq? (tc:type trap-context) #:return)
+      ;; We're in the context of an exit-frame trap.  Trap should only
+      ;; be run if exit-depth is set and this exit-frame has returned
+      ;; past the set depth.
+      (and (slot-ref trap 'exit-depth)
+	   (next-method)
+	   ;; OK to run the trap here, but we should first reset the
+	   ;; exit-depth slot to indicate that the step after this one
+	   ;; must be an application or frame entry.
+	   (begin
+	     (slot-set! trap 'exit-depth #f)
+	     #t))
+      ;; We're in the context of an application or frame entry trap.
+      ;; Check whether trap is limited to a specified file.
+      (let ((file-name (slot-ref trap 'file-name)))
+	(and (or (not file-name)
+		 (equal? (frame-file-name (tc:frame trap-context)) file-name))
+	     ;; Trap should run here, but we should also set exit-depth to
+	     ;; the current stack length, so that - if we don't stop at any
+	     ;; other steps first - the next step shows the return value of
+	     ;; the current application or evaluation.
+	     (begin
+	       (slot-set! trap 'exit-depth (tc:depth trap-context))
+	       (slot-set! trap 'depth (tc:depth trap-context))
+	       #t)))))
+
+(define (frame->source-position frame)
+  (let ((source (if (frame-procedure? frame)
+		    (or (frame-source frame)
+			(let ((proc (frame-procedure frame)))
+			  (and proc
+			       (procedure? proc)
+			       (procedure-source proc))))
+		    (frame-source frame))))
+    (and source
+	 (string? (source-property source 'filename))
+	 (list (source-property source 'filename)
+	       (source-property source 'line)
+	       (source-property source 'column)))))
+
+(define (frame-file-name frame)
+  (cond ((frame->source-position frame) => car)
+	(else #f)))
+
+;;; Class: <source-trap>
+;;;
+;;; An installed instance of <source-trap> triggers upon evaluation of
+;;; a specified source expression.
+(define-class <source-trap> (<trap>)
+  ;; "expression" slot: the expression to trap on.  This is
+  ;; implemented virtually, using the following weak vector slot, so
+  ;; as to avoid this trap preventing the GC of the target source
+  ;; code.
+  (expression #:init-keyword #:expression
+	      #:allocation #:virtual
+	      #:slot-ref
+	      (lambda (trap)
+		(vector-ref (slot-ref trap 'expression-wv) 0))
+	      #:slot-set!
+	      (lambda (trap expr)
+		(if (slot-bound? trap 'expression-wv)
+		    (vector-set! (slot-ref trap 'expression-wv) 0 expr)
+		    (slot-set! trap 'expression-wv (weak-vector expr)))))
+  (expression-wv)
+  ;; source property slots - for internal use only
+  (filename)
+  (line)
+  (column))
+
+;; Customization of the initialize method: get and save the
+;; expression's source properties, or signal an error if it doesn't
+;; have the necessary properties.
+(define-method (initialize (trap <source-trap>) initargs)
+  (next-method)
+  (let* ((expr (slot-ref trap 'expression))
+	 (filename (source-property expr 'filename))
+         (line (source-property expr 'line))
+         (column (source-property expr 'column))
+	 (existing-traps (volatile-target-traps expr)))
+    (or (and filename line column)
+        (error "Specified source does not have the necessary properties"
+               filename line column))
+    (slot-set! trap 'filename filename)
+    (slot-set! trap 'line line)
+    (slot-set! trap 'column column)
+    ;; If this is the target's first trap, give the target expression
+    ;; to the volatile-target-guardian, so we can find out if it
+    ;; becomes inaccessible.
+    (or existing-traps (volatile-target-guardian expr))
+    ;; Add this trap to the target expression's list of traps.
+    (set! (volatile-target-traps expr)
+	  (cons trap (or existing-traps '())))))
+
+;; Just in case more than one trap is installed on the same source
+;; expression ... so that we can still get the setting and resetting
+;; of the 'breakpoint source property correct.
+(define source-breakpoint-count (make-object-property))
+
+(define-method (install-trap (trap <source-trap>))
+  (next-method)
+  (let* ((expr (slot-ref trap 'expression))
+         (breakpoint-count (or (source-breakpoint-count expr) 0)))
+    (set-source-property! expr 'breakpoint #t)
+    (set! (source-breakpoint-count expr) (+ breakpoint-count 1)))
+  (install-breakpoint-trap trap))
+
+(define-method (uninstall-trap (trap <source-trap>))
+  (next-method)
+  (let* ((expr (slot-ref trap 'expression))
+         (breakpoint-count (or (source-breakpoint-count expr) 0)))
+    (if (= breakpoint-count 1)
+        (set-source-property! expr 'breakpoint #f))
+    (set! (source-breakpoint-count expr) (- breakpoint-count 1)))
+  (uninstall-breakpoint-trap trap))
+
+(define-method (trap-runnable? (trap <source-trap>)
+			       (trap-context <trap-context>))
+  (or (eq? (slot-ref trap 'expression)
+           (tc:expression trap-context))
+      (let ((trap-location (frame->source-position (tc:frame trap-context))))
+        (and trap-location
+             (string=? (car trap-location) (slot-ref trap 'filename))
+             (= (cadr trap-location) (slot-ref trap 'line))
+             (= (caddr trap-location) (slot-ref trap 'column))))))
+
+;; (trap-here EXPRESSION . OPTIONS)
+(define trap-here
+  (procedure->memoizing-macro
+   (lambda (expr env)
+     (let ((trap (apply make
+                        <source-trap>
+                        #:expression expr
+                        (local-eval `(list ,@(cddr expr))
+                                    env))))
+       (install-trap trap)
+       (set-car! expr 'begin)
+       (set-cdr! (cdr expr) '())
+       expr))))
+
+;;; Class: <location-trap>
+;;;
+;;; An installed instance of <location-trap> triggers on entry to a
+;;; frame with a more-or-less precisely specified source location.
+(define-class <location-trap> (<trap>)
+  ;; "file-regexp" slot: regexp matching the name(s) of the file(s) to
+  ;; trap in.
+  (file-regexp #:init-keyword #:file-regexp)
+  ;; "line" and "column" slots: position to trap at (0-based).
+  (line #:init-value #f #:init-keyword #:line)
+  (column #:init-value #f #:init-keyword #:column)
+  ;; "compiled-regexp" slot - self explanatory, internal use only
+  (compiled-regexp))
+
+(define-method (initialize (trap <location-trap>) initargs)
+  (next-method)
+  (slot-set! trap 'compiled-regexp
+             (make-regexp (slot-ref trap 'file-regexp))))
+
+(define-method (install-trap (trap <location-trap>))
+  (next-method)
+  (install-enter-frame-trap trap))
+
+(define-method (uninstall-trap (trap <location-trap>))
+  (next-method)
+  (uninstall-enter-frame-trap trap))
+
+(define-method (trap-runnable? (trap <location-trap>)
+			       (trap-context <trap-context>))
+  (and-let* ((trap-location (frame->source-position (tc:frame trap-context)))
+	     (tcline (cadr trap-location))
+	     (tccolumn (caddr trap-location)))
+    (and (= tcline (slot-ref trap 'line))
+	 (= tccolumn (slot-ref trap 'column))
+         (regexp-exec (slot-ref trap 'compiled-regexp)
+		      (car trap-location) 0))))
+
+;;; {Misc Trap Utilities}
+
+(define (get-trap number)
+  (hash-ref all-traps number))
+
+(define (list-traps)
+  (for-each describe
+	    (map cdr (sort (hash-fold acons '() all-traps)
+			   (lambda (x y) (< (car x) (car y)))))))
+
+;;; {Volatile Traps}
+;;;
+;;; Some traps are associated with Scheme objects that are likely to
+;;; be GC'd, such as procedures and read expressions.  When those
+;;; objects are GC'd, we want to allow their traps to evaporate as
+;;; well, or at least not to prevent them from doing so because they
+;;; are (now pointlessly) included on the various installed trap
+;;; lists.
+
+;; An object property that maps each volatile target to the list of
+;; traps that are installed on it.
+(define volatile-target-traps (make-object-property))
+
+;; A guardian that tells us when a volatile target is no longer
+;; accessible.
+(define volatile-target-guardian (make-guardian))
+
+;; An after GC hook that checks for newly inaccessible targets.
+(add-hook! after-gc-hook
+	   (lambda ()
+	     (trc 'after-gc-hook)
+	     (let loop ((target (volatile-target-guardian)))
+	       (if target
+                   ;; We have a target which is now inaccessible.  Get
+                   ;; the list of traps installed on it.
+		   (begin
+		     (trc 'after-gc-hook "got target")
+		     ;; Uninstall all the traps that are installed on
+		     ;; this target.
+		     (for-each (lambda (trap)
+				 (trc 'after-gc-hook "got trap")
+				 ;; If the trap is still installed,
+				 ;; uninstall it.
+				 (if (slot-ref trap 'installed)
+				     (uninstall-trap trap))
+				 ;; If the trap has an observer, tell
+				 ;; it that the target has gone.
+				 (cond ((slot-ref trap 'observer)
+					=>
+					(lambda (proc)
+					  (trc 'after-gc-hook "call obs")
+					  (proc 'target-gone)))))
+			       (or (volatile-target-traps target) '()))
+                     ;; Check for any more inaccessible targets.
+		     (loop (volatile-target-guardian)))))))
+
+(define (without-traps thunk)
+  (with-traps (lambda ()
+		(trap-disable 'traps)
+		(thunk))))
+
+(define guile-trap-features
+  ;; Helper procedure, to test whether a specific possible Guile
+  ;; feature is supported.
+  (let ((supported?
+         (lambda (test-feature)
+           (case test-feature
+             ((tweaking)
+              ;; Tweaking is supported if the description of the cheap
+              ;; traps option includes the word "obsolete", or if the
+              ;; option isn't there any more.
+              (and (string>=? (version) "1.7")
+                   (let ((cheap-opt-desc
+                          (assq 'cheap (debug-options-interface 'help))))
+                     (or (not cheap-opt-desc)
+                         (string-match "obsolete" (caddr cheap-opt-desc))))))
+             (else
+              (error "Unexpected feature name:" test-feature))))))
+    ;; Compile the list of actually supported features from all
+    ;; possible features.
+    (let loop ((possible-features '(tweaking))
+               (actual-features '()))
+      (if (null? possible-features)
+          (reverse! actual-features)
+          (let ((test-feature (car possible-features)))
+            (loop (cdr possible-features)
+                  (if (supported? test-feature)
+                      (cons test-feature actual-features)
+                      actual-features)))))))
+
+;; Make sure that traps are enabled.
+(trap-enable 'traps)
+
+;;; (ice-9 debugging traps) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/debugging/trc.scm

@@ -0,0 +1,63 @@
+;;;; (ice-9 debugging trc) -- tracing for Guile debugger code
+
+;;; Copyright (C) 2002, 2004 Free Software Foundation, Inc.
+;;;
+;; This library is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU Lesser General Public
+;; License as published by the Free Software Foundation; either
+;; version 2.1 of the License, or (at your option) any later version.
+;; 
+;; This library 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
+;; Lesser General Public License for more details.
+;; 
+;; You should have received a copy of the GNU Lesser General Public
+;; License along with this library; if not, write to the Free Software
+;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+(define-module (ice-9 debugging trc)
+  #:export (trc trc-syms trc-all trc-none trc-add trc-remove trc-port))
+
+(define *syms* #f)
+
+(define (trc-set! syms)
+  (set! *syms* syms))
+
+(define (trc-syms . syms)
+  (trc-set! syms))
+
+(define (trc-all)
+  (trc-set! #f))
+
+(define (trc-none)
+  (trc-set! '()))
+
+(define (trc-add sym)
+  (trc-set! (cons sym *syms*)))
+
+(define (trc-remove sym)
+  (trc-set! (delq1! sym *syms*)))
+
+(define (trc sym . args)
+  (if (or (not *syms*)
+	  (memq sym *syms*))
+      (let ((port (trc-port)))
+	(write sym port)
+	(display ":" port)
+	(for-each (lambda (arg)
+		    (display " " port)
+		    (write arg port))
+		  args)
+	(newline port))))
+
+(define trc-port
+  (let ((port (current-error-port)))
+    (make-procedure-with-setter
+     (lambda () port)
+     (lambda (p) (set! port p)))))
+
+;; Default to no tracing.
+(trc-none)
+
+;;; (ice-9 debugging trc) ends here.

node-addon-lilypond/output/share/guile/1.8/ice-9/deprecated.scm

@@ -0,0 +1,180 @@
+;;;; Copyright (C) 2003, 2005, 2006 Free Software Foundation, Inc.
+;;;;
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;;
+
+;;;; Deprecated definitions.
+
+(define substring-move-left! substring-move!)
+(define substring-move-right! substring-move!)
+
+;; This method of dynamically linking Guile Extensions is deprecated.
+;; Use `load-extension' explicitly from Scheme code instead.
+
+(define (split-c-module-name str)
+  (let loop ((rev '())
+	     (start 0)
+	     (pos 0)
+	     (end (string-length str)))
+    (cond
+     ((= pos end)
+      (reverse (cons (string->symbol (substring str start pos)) rev)))
+     ((eq? (string-ref str pos) #\space)
+      (loop (cons (string->symbol (substring str start pos)) rev)
+	    (+ pos 1)
+	    (+ pos 1)
+	    end))
+     (else
+      (loop rev start (+ pos 1) end)))))
+
+(define (convert-c-registered-modules dynobj)
+  (let ((res (map (lambda (c)
+		    (list (split-c-module-name (car c)) (cdr c) dynobj))
+		  (c-registered-modules))))
+    (c-clear-registered-modules)
+    res))
+
+(define registered-modules '())
+
+(define (register-modules dynobj)
+  (set! registered-modules
+	(append! (convert-c-registered-modules dynobj)
+		 registered-modules)))
+
+(define (warn-autoload-deprecation modname)
+  (issue-deprecation-warning
+   "Autoloading of compiled code modules is deprecated."
+   "Write a Scheme file instead that uses `load-extension'.")
+  (issue-deprecation-warning
+   (simple-format #f "(You just autoloaded module ~S.)" modname)))
+
+(define (init-dynamic-module modname)
+  ;; Register any linked modules which have been registered on the C level
+  (register-modules #f)
+  (or-map (lambda (modinfo)
+	    (if (equal? (car modinfo) modname)
+		(begin
+		  (warn-autoload-deprecation modname)
+		  (set! registered-modules (delq! modinfo registered-modules))
+		  (let ((mod (resolve-module modname #f)))
+		    (save-module-excursion
+		     (lambda ()
+		       (set-current-module mod)
+		       (set-module-public-interface! mod mod)
+		       (dynamic-call (cadr modinfo) (caddr modinfo))
+		       ))
+		    #t))
+		#f))
+	  registered-modules))
+
+(define (dynamic-maybe-call name dynobj)
+  (catch #t				; could use false-if-exception here
+	 (lambda ()
+	   (dynamic-call name dynobj))
+	 (lambda args
+	   #f)))
+
+(define (dynamic-maybe-link filename)
+  (catch #t				; could use false-if-exception here
+	 (lambda ()
+	   (dynamic-link filename))
+	 (lambda args
+	   #f)))
+
+(define (find-and-link-dynamic-module module-name)
+  (define (make-init-name mod-name)
+    (string-append "scm_init"
+		   (list->string (map (lambda (c)
+					(if (or (char-alphabetic? c)
+						(char-numeric? c))
+					    c
+					    #\_))
+				      (string->list mod-name)))
+		   "_module"))
+
+  ;; Put the subdirectory for this module in the car of SUBDIR-AND-LIBNAME,
+  ;; and the `libname' (the name of the module prepended by `lib') in the cdr
+  ;; field.  For example, if MODULE-NAME is the list (inet tcp-ip udp), then
+  ;; SUBDIR-AND-LIBNAME will be the pair ("inet/tcp-ip" . "libudp").
+  (let ((subdir-and-libname
+	 (let loop ((dirs "")
+		    (syms module-name))
+	   (if (null? (cdr syms))
+	       (cons dirs (string-append "lib" (symbol->string (car syms))))
+	       (loop (string-append dirs (symbol->string (car syms)) "/")
+		     (cdr syms)))))
+	(init (make-init-name (apply string-append
+				     (map (lambda (s)
+					    (string-append "_"
+							   (symbol->string s)))
+					  module-name)))))
+    (let ((subdir (car subdir-and-libname))
+	  (libname (cdr subdir-and-libname)))
+
+      ;; Now look in each dir in %LOAD-PATH for `subdir/libfoo.la'.  If that
+      ;; file exists, fetch the dlname from that file and attempt to link
+      ;; against it.  If `subdir/libfoo.la' does not exist, or does not seem
+      ;; to name any shared library, look for `subdir/libfoo.so' instead and
+      ;; link against that.
+      (let check-dirs ((dir-list %load-path))
+	(if (null? dir-list)
+	    #f
+	    (let* ((dir (in-vicinity (car dir-list) subdir))
+		   (sharlib-full
+		    (or (try-using-libtool-name dir libname)
+			(try-using-sharlib-name dir libname))))
+	      (if (and sharlib-full (file-exists? sharlib-full))
+		  (link-dynamic-module sharlib-full init)
+		  (check-dirs (cdr dir-list)))))))))
+
+(define (try-using-libtool-name libdir libname)
+  (let ((libtool-filename (in-vicinity libdir
+				       (string-append libname ".la"))))
+    (and (file-exists? libtool-filename)
+	 libtool-filename)))
+
+(define (try-using-sharlib-name libdir libname)
+  (in-vicinity libdir (string-append libname ".so")))
+
+(define (link-dynamic-module filename initname)
+  ;; Register any linked modules which have been registered on the C level
+  (register-modules #f)
+  (let ((dynobj (dynamic-link filename)))
+    (dynamic-call initname dynobj)
+    (register-modules dynobj)))
+
+(define (try-module-linked module-name)
+  (init-dynamic-module module-name))
+
+(define (try-module-dynamic-link module-name)
+  (and (find-and-link-dynamic-module module-name)
+       (init-dynamic-module module-name)))
+
+(define (list* . args)
+  (issue-deprecation-warning "'list*' is deprecated.  Use 'cons*' instead.")
+  (apply cons* args))
+
+;; The strange prototype system for uniform arrays has been
+;; deprecated.
+
+(define uniform-vector-fill! array-fill!)
+
+(define make-uniform-vector dimensions->uniform-array)
+
+(define (make-uniform-array prot . bounds)
+  (dimensions->uniform-array bounds prot))
+ 
+(define (list->uniform-vector prot lst)
+  (list->uniform-array 1 prot lst))

node-addon-lilypond/output/share/guile/1.8/ice-9/documentation.scm

@@ -0,0 +1,213 @@
+;;;; 	Copyright (C) 2000,2001, 2002, 2003, 2006 Free Software Foundation, Inc.
+;;;;
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;;
+
+;;; Commentary:
+
+;; * This module exports:
+;;
+;; file-commentary      -- a procedure that returns a file's "commentary"
+;;
+;; documentation-files  -- a search-list of files using the Guile
+;;                         Documentation Format Version 2.
+;;
+;; search-documentation-files -- a procedure that takes NAME (a symbol)
+;;                               and searches `documentation-files' for
+;;                               associated documentation.  optional
+;;                               arg FILES is a list of filenames to use
+;;                               instead of `documentation-files'.
+;;
+;; object-documentation -- a procedure that returns its arg's docstring
+;;
+;; * Guile Documentation Format
+;;
+;; Here is the complete and authoritative documentation for the Guile
+;; Documentation Format Version 2:
+;;
+;; HEADER
+;; ^LPROC1
+;; DOCUMENTATION1
+;;
+;; ^LPROC2
+;; DOCUMENTATION2
+;;
+;; ^L...
+;;
+;; The HEADER is completely ignored.  The "^L" are formfeeds.  PROC1, PROC2
+;; and so on are symbols that name the element documented.  DOCUMENTATION1,
+;; DOCUMENTATION2 and so on are the related documentation, w/o any further
+;; formatting.  Note that there are two newlines before the next formfeed;
+;; these are discarded when the documentation is read in.
+;;
+;; (Version 1, corresponding to guile-1.4 and prior, is documented as being
+;; not documented anywhere except by this embarrassingly circular comment.)
+;;
+;; * File Commentary
+;;
+;; A file's commentary is the body of text found between comments
+;;     ;;; Commentary:
+;; and
+;;     ;;; Code:
+;; both of which must be at the beginning of the line.  In the result string,
+;; semicolons at the beginning of each line are discarded.
+;;
+;; You can specify to `file-commentary' alternate begin and end strings, and
+;; scrub procedure.  Use #t to get default values.  For example:
+;;
+;; (file-commentary "documentation.scm")
+;; You should see this text!
+;;
+;; (file-commentary "documentation.scm" "^;;; Code:" "ends here$")
+;; You should see the rest of this file.
+;;
+;; (file-commentary "documentation.scm" #t #t string-upcase)
+;; You should see this text very loudly (note semicolons untouched).
+
+;;; Code:
+
+(define-module (ice-9 documentation)
+  :use-module (ice-9 rdelim)
+  :export (file-commentary
+           documentation-files search-documentation-files
+           object-documentation)
+  :autoload (ice-9 regex) (match:suffix)
+  :no-backtrace)
+
+
+;;
+;; commentary extraction
+;;
+
+(define (file-commentary filename . cust) ; (IN-LINE-RE AFTER-LINE-RE SCRUB)
+   
+  ;; These are constants but are not at the top level because the repl in
+  ;; boot-9.scm loads session.scm which in turn loads this file, and we want
+  ;; that to work even even when regexps are not available (ie. make-regexp
+  ;; doesn't exist), as for instance is the case on mingw.
+  ;;
+  (define default-in-line-re (make-regexp "^;;; Commentary:"))
+  (define default-after-line-re (make-regexp "^;;; Code:"))
+  (define default-scrub (let ((dirt (make-regexp "^;+")))
+			  (lambda (line)
+			    (let ((m (regexp-exec dirt line)))
+			      (if m (match:suffix m) line)))))
+       
+  ;; fixme: might be cleaner to use optargs here...
+  (let ((in-line-re (if (> 1 (length cust))
+                        default-in-line-re
+                        (let ((v (car cust)))
+                          (cond ((regexp? v) v)
+                                ((string? v) (make-regexp v))
+                                (else default-in-line-re)))))
+        (after-line-re (if (> 2 (length cust))
+                           default-after-line-re
+                           (let ((v (cadr cust)))
+                             (cond ((regexp? v) v)
+                                   ((string? v) (make-regexp v))
+                                   (else default-after-line-re)))))
+        (scrub (if (> 3 (length cust))
+                   default-scrub
+                   (let ((v (caddr cust)))
+                     (cond ((procedure? v) v)
+                           (else default-scrub))))))
+    (call-with-input-file filename
+      (lambda (port)
+	(let loop ((line (read-delimited "\n" port))
+		   (doc "")
+		   (parse-state 'before))
+	  (if (or (eof-object? line) (eq? 'after parse-state))
+	      doc
+	      (let ((new-state
+		     (cond ((regexp-exec in-line-re line) 'in)
+			   ((regexp-exec after-line-re line) 'after)
+			   (else parse-state))))
+		(if (eq? 'after new-state)
+		    doc
+		    (loop (read-delimited "\n" port)
+			  (if (and (eq? 'in new-state) (eq? 'in parse-state))
+			      (string-append doc (scrub line) "\n")
+			      doc)
+			  new-state)))))))))
+
+
+
+;;
+;; documentation-files is the list of places to look for documentation
+;;
+(define documentation-files
+  (map (lambda (vicinity)
+	 (in-vicinity (vicinity) "guile-procedures.txt"))
+       (list %library-dir
+	     %package-data-dir
+	     %site-dir
+	     (lambda () "."))))
+
+(define entry-delimiter "\f")
+
+(define (find-documentation-in-file name file)
+  (and (file-exists? file)
+       (call-with-input-file file
+	 (lambda (port)
+	   (let ((name (symbol->string name)))
+	     (let ((len (string-length name)))
+	       (read-delimited entry-delimiter port) ;skip to first entry
+	       (let loop ((entry (read-delimited entry-delimiter port)))
+		 (cond ((eof-object? entry) #f)
+		       ;; match?
+		       ((and ;; large enough?
+		         (>= (string-length entry) len)
+			 ;; matching name?
+			 (string=? (substring entry 0 len) name)
+			 ;; terminated?
+			 (memq (string-ref entry len) '(#\newline)))
+			;; cut away name tag and extra surrounding newlines
+			(substring entry (+ len 2) (- (string-length entry) 2)))
+		       (else (loop (read-delimited entry-delimiter port)))))))))))
+
+(define (search-documentation-files name . files)
+  (or-map (lambda (file)
+	    (find-documentation-in-file name file))
+          (cond ((null? files) documentation-files)
+                (else files))))
+
+;; helper until the procedure documentation property is cleaned up
+(define (proc-doc proc)
+  (or (procedure-documentation proc)
+      (procedure-property proc 'documentation)))
+
+(define (object-documentation object)
+  "Return the docstring for OBJECT.
+OBJECT can be a procedure, macro or any object that has its
+`documentation' property set."
+  (or (and (procedure? object)
+	   (proc-doc object))
+      (and (defmacro? object)
+	   (proc-doc (defmacro-transformer object)))
+      (and (macro? object)
+	   (let ((transformer (macro-transformer object)))
+	     (and transformer
+		  (proc-doc transformer))))
+      (object-property object 'documentation)
+      (and (procedure? object)
+	   (not (closure? object))
+	   (procedure-name object)
+	   (let ((docstring (search-documentation-files
+                             (procedure-name object))))
+	     (if docstring
+		 (set-procedure-property! object 'documentation docstring))
+	     docstring))))
+
+;;; documentation.scm ends here

node-addon-lilypond/output/share/guile/1.8/ice-9/emacs.scm

@@ -0,0 +1,276 @@
+;;;; 	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2006 Free Software Foundation, Inc.
+;;;; 
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;;
+;;;; The author can be reached at djurfeldt@nada.kth.se
+;;;; Mikael Djurfeldt, SANS/NADA KTH, 10044 STOCKHOLM, SWEDEN
+;;;; (I didn't write this!)
+;;;;
+
+
+;;; *********************************************************************
+;;; * This is the Guile side of the Emacs interface                     *
+;;; * Experimental hACK---the real version will be coming soon (almost) *
+;;; *********************************************************************
+
+;;; {Session support for Emacs}
+;;;
+
+(define-module (ice-9 emacs)
+  :use-module (ice-9 debug)
+  :use-module (ice-9 threads)
+  :use-module (ice-9 session)
+  :no-backtrace)
+
+(define emacs-escape-character #\sub)
+
+(define emacs-output-port (current-output-port))
+
+(define (make-emacs-command char)
+  (let ((cmd (list->string (list emacs-escape-character char))))
+    (lambda ()
+      (display cmd emacs-output-port))))
+
+(define enter-input-wait  (make-emacs-command #\s))
+(define exit-input-wait   (make-emacs-command #\f))
+(define enter-read-character #\r)
+(define sending-error	  (make-emacs-command #\F))
+(define sending-backtrace (make-emacs-command #\B))
+(define sending-result    (make-emacs-command #\x))
+(define end-of-text	  (make-emacs-command #\.))
+(define no-stack	  (make-emacs-command #\S))
+(define no-source	  (make-emacs-command #\R))
+
+;; {Error handling}
+;;
+
+(add-hook! before-backtrace-hook sending-backtrace)
+(add-hook! after-backtrace-hook end-of-text)
+(add-hook! before-error-hook sending-error)
+(add-hook! after-error-hook end-of-text)
+
+;; {Repl}
+;;
+
+(set-current-error-port emacs-output-port)
+
+(add-hook! before-read-hook
+	   (lambda ()
+	     (enter-input-wait)
+	     (force-output emacs-output-port)))
+
+(add-hook! after-read-hook
+	   (lambda ()
+	     (exit-input-wait)
+	     (force-output emacs-output-port)))
+
+;;; {Misc.}
+
+(define (make-emacs-load-port orig-port)
+  (letrec ((read-char-fn  (lambda args
+			    (let ((c (read-char orig-port)))
+			      (if (eq? c #\soh)
+				  (throw 'end-of-chunk)
+				  c)))))
+    
+    (make-soft-port
+     (vector #f #f #f
+	     read-char-fn
+	     (lambda () (close-port orig-port)))
+     "r")))
+
+(set-current-input-port (make-emacs-load-port (current-input-port)))
+
+(define (result-to-emacs exp)
+  (sending-result)
+  (write exp emacs-output-port)
+  (end-of-text)
+  (force-output emacs-output-port))
+
+(define load-acknowledge (make-emacs-command #\l))
+
+(define load-port (current-input-port))
+
+(define (flush-line port)
+  (let loop ((c (read-char port)))
+    (if (not (eq? c #\nl))
+	(loop (read-char port)))))
+
+(define whitespace-chars (list #\space #\tab #\nl #\np))
+
+(define (flush-whitespace port)
+  (catch 'end-of-chunk
+	 (lambda ()
+	   (let loop ((c (read-char port)))
+	     (cond ((eq? c the-eof-object)
+		    (error "End of file while receiving Emacs data"))
+		   ((memq c whitespace-chars) (loop (read-char port)))
+		   ((eq? c #\;) (flush-line port) (loop (read-char port)))
+		   (else (unread-char c port))))
+	   #f)
+	 (lambda args
+	   (read-char port) ; Read final newline
+	   #t)))
+
+(define (emacs-load filename linum colnum module interactivep)
+  (define (read-and-eval! port)
+    (let ((x (read port)))
+      (if (eof-object? x)
+	  (throw 'end-of-file)
+	  (primitive-eval x))))
+  (set-port-filename! %%load-port filename)
+  (set-port-line! %%load-port linum)
+  (set-port-column! %%load-port colnum)
+  (lazy-catch #t
+	      (lambda ()
+		(let loop ((endp (flush-whitespace %%load-port)))
+		  (if (not endp)
+		      (begin
+			(save-module-excursion
+			 (lambda ()
+			   (if module
+			       (set-current-module (resolve-module module #f)))
+			   (let ((result
+				  (start-stack read-and-eval!
+					       (read-and-eval! %%load-port))))
+			     (if interactivep
+				 (result-to-emacs result)))))
+			(loop (flush-whitespace %%load-port)))
+		      (begin
+			(load-acknowledge)))
+		  (set-port-filename! %%load-port #f)))	;reset port filename
+	      (lambda (key . args)
+		(set-port-filename! %%load-port #f)
+		(cond ((eq? key 'end-of-chunk)
+		       (fluid-set! the-last-stack #f)
+		       (set! stack-saved? #t)
+		       (scm-error 'misc-error
+				  #f
+				  "Incomplete expression"
+				  '()
+				  '()))
+		      ((eq? key 'exit))
+		      (else
+		       (save-stack 2)
+		       (catch 'end-of-chunk
+			      (lambda ()
+				(let loop ()
+				  (read-char %%load-port)
+				  (loop)))
+			      (lambda args
+				#f))
+		       (apply throw key args))))))
+
+(define (emacs-eval-request form)
+  (result-to-emacs (eval form (interaction-environment))))
+
+;;*fixme* Not necessary to use flags no-stack and no-source
+(define (get-frame-source frame)
+  (if (or (not (fluid-ref the-last-stack))
+	  (>= frame (stack-length (fluid-ref the-last-stack))))
+      (begin
+	(no-stack)
+	#f)
+      (let* ((frame (stack-ref (fluid-ref the-last-stack)
+			       (frame-number->index frame)))
+	     (source (frame-source frame)))
+	(or source
+	    (begin (no-source)
+		   #f)))))
+
+(define (emacs-select-frame frame)
+  (let ((source (get-frame-source frame)))
+    (if source
+	(let ((fname (source-property source 'filename))
+	      (line (source-property source 'line))
+	      (column (source-property source 'column)))
+	  (if (and fname line column)
+	      (list fname line column)
+	      (begin (no-source)
+		     '())))
+	'())))
+
+(define (object->string x . method)
+  (with-output-to-string
+    (lambda ()
+      ((if (null? method)
+	   write
+	   (car method))
+       x))))
+
+(define (format template . rest)
+  (let loop ((chars (string->list template))
+	     (result '())
+	     (rest rest))
+    (cond ((null? chars) (list->string (reverse result)))
+	  ((char=? (car chars) #\%)
+	   (loop (cddr chars)
+		 (append (reverse
+			  (string->list
+			   (case (cadr chars)
+			     ((#\S) (object->string (car rest)))
+			     ((#\s) (object->string (car rest) display)))))
+			 result)
+		 (cdr rest)))
+	  (else (loop (cdr chars) (cons (car chars) result) rest)))))
+
+(define (error-args->string args)
+  (let ((msg (apply format (caddr args) (cadddr args))))
+    (if (symbol? (cadr args))
+	(string-append (symbol->string (cadr args))
+		       ": "
+		       msg)
+	msg)))
+
+(define (emacs-frame-eval frame form)
+  (let ((source (get-frame-source frame)))
+    (if source
+	(catch #t
+	       (lambda ()
+		 (list 'result
+		       (object->string
+			(local-eval (with-input-from-string form read)
+				    (memoized-environment source)))))
+	       (lambda args
+		 (list (car args)
+		       (error-args->string args))))
+	(begin
+	  (no-source)
+	  '()))))
+
+(define (emacs-symdoc symbol)
+  (if (or (not (module-bound? (current-module) symbol))
+	  (not (procedure? (eval symbol (interaction-environment)))))
+      'nil
+      (procedure-documentation (eval symbol (interaction-environment)))))
+
+;;; A fix to get the emacs interface to work together with the module system.
+;;;
+(for-each (lambda (name value)
+	    (module-define! the-root-module name value))
+	  '(%%load-port
+	    %%emacs-load
+	    %%emacs-eval-request
+	    %%emacs-select-frame
+	    %%emacs-frame-eval
+	    %%emacs-symdoc
+	    %%apropos-internal)
+	  (list load-port
+		emacs-load
+		emacs-eval-request
+		emacs-select-frame
+		emacs-frame-eval
+		emacs-symdoc
+		apropos-internal))

node-addon-lilypond/output/share/guile/1.8/ice-9/expect.scm

@@ -0,0 +1,171 @@
+;;;; 	Copyright (C) 1996, 1998, 1999, 2001, 2006 Free Software Foundation, Inc.
+;;;;
+;;;; This library is free software; you can redistribute it and/or
+;;;; modify it under the terms of the GNU Lesser General Public
+;;;; License as published by the Free Software Foundation; either
+;;;; version 2.1 of the License, or (at your option) any later version.
+;;;; 
+;;;; This library 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
+;;;; Lesser General Public License for more details.
+;;;; 
+;;;; You should have received a copy of the GNU Lesser General Public
+;;;; License along with this library; if not, write to the Free Software
+;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+;;;;
+
+;;; Commentary:
+
+;; This module is documented in the Guile Reference Manual.
+;; Briefly, these are exported:
+;;  procedures: expect-select, expect-regexec
+;;   variables: expect-port, expect-timeout, expect-timeout-proc,
+;;              expect-eof-proc, expect-char-proc,
+;;              expect-strings-compile-flags, expect-strings-exec-flags,
+;;      macros: expect, expect-strings
+
+;;; Code:
+
+(define-module (ice-9 expect)
+  :use-module (ice-9 regex)
+  :export-syntax (expect expect-strings)
+  :export (expect-port expect-timeout expect-timeout-proc
+	   expect-eof-proc expect-char-proc expect-strings-compile-flags
+	   expect-strings-exec-flags expect-select expect-regexec))
+
+;;; Expect: a macro for selecting actions based on what it reads from a port.
+;;; The idea is from Don Libes' expect based on Tcl.
+;;; This version by Gary Houston incorporating ideas from Aubrey Jaffer.
+
+
+(define expect-port #f)
+(define expect-timeout #f)
+(define expect-timeout-proc #f)
+(define expect-eof-proc #f)
+(define expect-char-proc #f)
+
+;;; expect: each test is a procedure which is applied to the accumulating
+;;; string.
+(defmacro expect clauses
+  (let ((s (gensym))
+	(c (gensym))
+	(port (gensym))
+	(timeout (gensym)))
+    `(let ((,s "")
+	   (,port (or expect-port (current-input-port)))
+	   ;; when timeout occurs, in floating point seconds.
+	   (,timeout (if expect-timeout
+			 (let* ((secs-usecs (gettimeofday)))
+			   (+ (car secs-usecs)
+			      expect-timeout
+			      (/ (cdr secs-usecs)
+				 1000000))) ; one million.
+			 #f)))
+       (let next-char ()
+	 (if (and expect-timeout
+		  (not (expect-select ,port ,timeout)))
+	     (if expect-timeout-proc
+		 (expect-timeout-proc ,s)
+		 #f)
+	     (let ((,c (read-char ,port)))
+	       (if expect-char-proc
+		   (expect-char-proc ,c))
+	       (if (not (eof-object? ,c))
+		   (set! ,s (string-append ,s (string ,c))))
+	       (cond
+		;; this expands to clauses where the car invokes the
+		;; match proc and the cdr is the return value from expect
+		;; if the proc matched.
+		,@(let next-expr ((tests (map car clauses))
+				  (exprs (map cdr clauses))
+				  (body '()))
+		    (cond
+		     ((null? tests)
+		      (reverse body))
+		     (else
+		      (next-expr
+		       (cdr tests)
+		       (cdr exprs)
+		       (cons
+			`((,(car tests) ,s (eof-object? ,c))
+			  ,@(cond ((null? (car exprs))
+				   '())
+				  ((eq? (caar exprs) '=>)
+				   (if (not (= (length (car exprs))
+					       2))
+				       (scm-error 'misc-error
+						  "expect"
+						  "bad recipient: ~S"
+						  (list (car exprs))
+						  #f)
+				       `((apply ,(cadar exprs)
+						(,(car tests) ,s ,port)))))
+				  (else
+				   (car exprs))))
+			body)))))
+		;; if none of the clauses matched the current string.
+		(else (cond ((eof-object? ,c)
+			     (if expect-eof-proc
+				 (expect-eof-proc ,s)
+				 #f))
+			    (else
+			     (next-char)))))))))))
+
+
+(define expect-strings-compile-flags regexp/newline)
+(define expect-strings-exec-flags regexp/noteol)
+
+;;; the regexec front-end to expect:
+;;; each test must evaluate to a regular expression.
+(defmacro expect-strings clauses
+  `(let ,@(let next-test ((tests (map car clauses))
+			  (exprs (map cdr clauses))
+			  (defs '())
+			  (body '()))
+	    (cond ((null? tests)
+		   (list (reverse defs) `(expect ,@(reverse body))))
+		  (else
+		   (let ((rxname (gensym)))
+		     (next-test (cdr tests)
+				(cdr exprs)
+				(cons `(,rxname (make-regexp
+						 ,(car tests)
+						 expect-strings-compile-flags))
+				      defs)
+				(cons `((lambda (s eof?)
+					  (expect-regexec ,rxname s eof?))
+					,@(car exprs))
+				      body))))))))
+
+;;; simplified select: returns #t if input is waiting or #f if timed out or
+;;; select was interrupted by a signal.
+;;; timeout is an absolute time in floating point seconds.
+(define (expect-select port timeout)
+  (let* ((secs-usecs (gettimeofday))
+	 (relative (- timeout
+		      (car secs-usecs)
+		      (/ (cdr secs-usecs)
+			 1000000))))	; one million.
+    (and (> relative 0)
+	 (pair? (car (select (list port) '() '()
+			     relative))))))
+
+;;; match a string against a regexp, returning a list of strings (required
+;;; by the => syntax) or #f.  called once each time a character is added
+;;; to s (eof? will be #f), and once when eof is reached (with eof? #t).
+(define (expect-regexec rx s eof?)
+  ;; if expect-strings-exec-flags contains regexp/noteol,
+  ;; remove it for the eof test.
+  (let* ((flags (if (and eof?
+			 (logand expect-strings-exec-flags regexp/noteol))
+		    (logxor expect-strings-exec-flags regexp/noteol)
+		    expect-strings-exec-flags))
+	 (match (regexp-exec rx s 0 flags)))
+    (if match
+	(do ((i (- (match:count match) 1) (- i 1))
+	     (result '() (cons (match:substring match i) result)))
+	    ((< i 0) result))
+	#f)))
+
+;;; expect.scm ends here