---input---
;;; installed-scm-file

;;;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; the Free Software Foundation; either version 2, or (at your option)
;;;; any later version.
;;;;
;;;; This program is distributed in the hope that it will be useful,
;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;;; GNU General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU General Public License
;;;; along with this software; see the file COPYING.  If not, write to
;;;; the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
;;;; Boston, MA 02111-1307 USA
;;;;
;;;; As a special exception, the Free Software Foundation gives permission
;;;; for additional uses of the text contained in its release of GUILE.
;;;;
;;;; The exception is that, if you link the GUILE library with other files
;;;; to produce an executable, this does not by itself cause the
;;;; resulting executable to be covered by the GNU General Public License.
;;;; Your use of that executable is in no way restricted on account of
;;;; linking the GUILE library code into it.
;;;;
;;;; This exception does not however invalidate any other reasons why
;;;; the executable file might be covered by the GNU General Public License.
;;;;
;;;; This exception applies only to the code released by the
;;;; Free Software Foundation under the name GUILE.  If you copy
;;;; code from other Free Software Foundation releases into a copy of
;;;; GUILE, as the General Public License permits, the exception does
;;;; not apply to the code that you add in this way.  To avoid misleading
;;;; anyone as to the status of such modified files, you must delete
;;;; this exception notice from them.
;;;;
;;;; If you write modifications of your own for GUILE, it is your choice
;;;; whether to permit this exception to apply to your modifications.
;;;; If you do not wish that, delete this exception notice.
;;;;


;;; Commentary:

;;; This file is the first thing loaded into Guile.  It adds many mundane
;;; definitions and a few that are interesting.
;;;
;;; The module system (hence the hierarchical namespace) are defined in this
;;; file.
;;;

;;; Code:


;;; {Deprecation}
;;;

;; We don't have macros here, but we do want to define
;; `begin-deprecated' early.

(define begin-deprecated
  (procedure->memoizing-macro
   (lambda (exp env)
     (if (include-deprecated-features)
	 `(begin ,@(cdr exp))
	 `#f))))


;;; {Features}
;;

(define (provide sym)
  (if (not (memq sym *features*))
      (set! *features* (cons sym *features*))))

;;; Return #t iff FEATURE is available to this Guile interpreter.
;;; In SLIB, provided? also checks to see if the module is available.
;;; We should do that too, but don't.
(define (provided? feature)
  (and (memq feature *features*) #t))

(begin-deprecated
 (define (feature? sym)
   (issue-deprecation-warning
    "`feature?' is deprecated.  Use `provided?' instead.")
   (provided? sym)))

;;; let format alias simple-format until the more complete version is loaded
(define format simple-format)


;;; {R4RS compliance}

(primitive-load-path "ice-9/r4rs.scm")


;;; {Simple Debugging Tools}
;;


;; peek takes any number of arguments, writes them to the
;; current ouput port, and returns the last argument.
;; It is handy to wrap around an expression to look at
;; a value each time is evaluated, e.g.:
;;
;;	(+ 10 (troublesome-fn))
;;	=> (+ 10 (pk 'troublesome-fn-returned (troublesome-fn)))
;;

(define (peek . stuff)
  (newline)
  (display ";;; ")
  (write stuff)
  (newline)
  (car (last-pair stuff)))

(define pk peek)

(define (warn . stuff)
  (with-output-to-port (current-error-port)
    (lambda ()
      (newline)
      (display ";;; WARNING ")
      (display stuff)
      (newline)
      (car (last-pair stuff)))))


;;; {Trivial Functions}
;;;

(define (identity x) x)
(define (1+ n) (+ n 1))
(define (1- n) (+ n -1))
(define (and=> value procedure) (and value (procedure value)))
(define (make-hash-table k) (make-vector k '()))

(begin-deprecated
 (define (id x)
   (issue-deprecation-warning "`id' is deprecated.  Use `identity' instead.")
   (identity x))
 (define (-1+ n)
   (issue-deprecation-warning "`-1+' is deprecated.  Use `1-' instead.")
   (1- n))
 (define (return-it . args)
   (issue-deprecation-warning "`return-it' is deprecated.  Use `noop' instead.")
   (apply noop args)))

;;; apply-to-args is functionally redundant with apply and, worse,
;;; is less general than apply since it only takes two arguments.
;;;
;;; On the other hand, apply-to-args is a syntacticly convenient way to
;;; perform binding in many circumstances when the "let" family of
;;; of forms don't cut it.  E.g.:
;;;
;;;	(apply-to-args (return-3d-mouse-coords)
;;;	  (lambda (x y z)
;;;		...))
;;;

(define (apply-to-args args fn) (apply fn args))



;;; {Integer Math}
;;;

(define (ipow-by-squaring x k acc proc)
  (cond ((zero? k) acc)
	((= 1 k) (proc acc x))
	(else (ipow-by-squaring (proc x x)
				(quotient k 2)
				(if (even? k) acc (proc acc x))
				proc))))

(begin-deprecated
 (define (string-character-length s)
   (issue-deprecation-warning "`string-character-length' is deprecated.  Use `string-length' instead.")
   (string-length s))
 (define (flags . args)
   (issue-deprecation-warning "`flags' is deprecated.  Use `logior' instead.")
   (apply logior args)))


;;; {Symbol Properties}
;;;

(define (symbol-property sym prop)
  (let ((pair (assoc prop (symbol-pref sym))))
    (and pair (cdr pair))))

(define (set-symbol-property! sym prop val)
  (let ((pair (assoc prop (symbol-pref sym))))
    (if pair
	(set-cdr! pair val)
	(symbol-pset! sym (acons prop val (symbol-pref sym))))))

(define (symbol-property-remove! sym prop)
  (let ((pair (assoc prop (symbol-pref sym))))
    (if pair
	(symbol-pset! sym (delq! pair (symbol-pref sym))))))

;;; {General Properties}
;;;

;; This is a more modern interface to properties.  It will replace all
;; other property-like things eventually.

(define (make-object-property)
  (let ((prop (primitive-make-property #f)))
    (make-procedure-with-setter
     (lambda (obj) (primitive-property-ref prop obj))
     (lambda (obj val) (primitive-property-set! prop obj val)))))



;;; {Arrays}
;;;

(if (provided? 'array)
    (primitive-load-path "ice-9/arrays.scm"))


;;; {Keywords}
;;;

(define (symbol->keyword symbol)
  (make-keyword-from-dash-symbol (symbol-append '- symbol)))

(define (keyword->symbol kw)
  (let ((sym (symbol->string (keyword-dash-symbol kw))))
    (string->symbol (substring sym 1 (string-length sym)))))

(define (kw-arg-ref args kw)
  (let ((rem (member kw args)))
    (and rem (pair? (cdr rem)) (cadr rem))))



;;; {Structs}

(define (struct-layout s)
  (struct-ref (struct-vtable s) vtable-index-layout))



;;; Environments

(define the-environment
  (procedure->syntax
   (lambda (x e)
     e)))

(define the-root-environment (the-environment))

(define (environment-module env)
  (let ((closure (and (pair? env) (car (last-pair env)))))
    (and closure (procedure-property closure 'module))))


;;; {Records}
;;;

;; Printing records: by default, records are printed as
;;
;;   #<type-name field1: val1 field2: val2 ...>
;;
;; You can change that by giving a custom printing function to
;; MAKE-RECORD-TYPE (after the list of field symbols).  This function
;; will be called like
;;
;;   (<printer> object port)
;;
;; It should print OBJECT to PORT.

(define (inherit-print-state old-port new-port)
  (if (get-print-state old-port)
      (port-with-print-state new-port (get-print-state old-port))
      new-port))

;; 0: type-name, 1: fields
(define record-type-vtable
  (make-vtable-vtable "prpr" 0
		      (lambda (s p)
			(cond ((eq? s record-type-vtable)
			       (display "#<record-type-vtable>" p))
			      (else
			       (display "#<record-type " p)
			       (display (record-type-name s) p)
			       (display ">" p))))))

(define (record-type? obj)
  (and (struct? obj) (eq? record-type-vtable (struct-vtable obj))))

(define (make-record-type type-name fields . opt)
  (let ((printer-fn (and (pair? opt) (car opt))))
    (let ((struct (make-struct record-type-vtable 0
			       (make-struct-layout
				(apply string-append
				       (map (lambda (f) "pw") fields)))
			       (or printer-fn
				   (lambda (s p)
				     (display "#<" p)
				     (display type-name p)
				     (let loop ((fields fields)
						(off 0))
				       (cond
					((not (null? fields))
					 (display " " p)
					 (display (car fields) p)
					 (display ": " p)
					 (display (struct-ref s off) p)
					 (loop (cdr fields) (+ 1 off)))))
				     (display ">" p)))
			       type-name
			       (copy-tree fields))))
      ;; Temporary solution: Associate a name to the record type descriptor
      ;; so that the object system can create a wrapper class for it.
      (set-struct-vtable-name! struct (if (symbol? type-name)
					  type-name
					  (string->symbol type-name)))
      struct)))

(define (record-type-name obj)
  (if (record-type? obj)
      (struct-ref obj vtable-offset-user)
      (error 'not-a-record-type obj)))

(define (record-type-fields obj)
  (if (record-type? obj)
      (struct-ref obj (+ 1 vtable-offset-user))
      (error 'not-a-record-type obj)))

(define (record-constructor rtd . opt)
  (let ((field-names (if (pair? opt) (car opt) (record-type-fields rtd))))
    (local-eval `(lambda ,field-names
		   (make-struct ',rtd 0 ,@(map (lambda (f)
						 (if (memq f field-names)
						     f
						     #f))
					       (record-type-fields rtd))))
		the-root-environment)))

(define (record-predicate rtd)
  (lambda (obj) (and (struct? obj) (eq? rtd (struct-vtable obj)))))

(define (record-accessor rtd field-name)
  (let* ((pos (list-index (record-type-fields rtd) field-name)))
    (if (not pos)
	(error 'no-such-field field-name))
    (local-eval `(lambda (obj)
		   (and (eq? ',rtd (record-type-descriptor obj))
			(struct-ref obj ,pos)))
		the-root-environment)))

(define (record-modifier rtd field-name)
  (let* ((pos (list-index (record-type-fields rtd) field-name)))
    (if (not pos)
	(error 'no-such-field field-name))
    (local-eval `(lambda (obj val)
		   (and (eq? ',rtd (record-type-descriptor obj))
			(struct-set! obj ,pos val)))
		the-root-environment)))


(define (record? obj)
  (and (struct? obj) (record-type? (struct-vtable obj))))

(define (record-type-descriptor obj)
  (if (struct? obj)
      (struct-vtable obj)
      (error 'not-a-record obj)))

(provide 'record)


;;; {Booleans}
;;;

(define (->bool x) (not (not x)))


;;; {Symbols}
;;;

(define (symbol-append . args)
  (string->symbol (apply string-append (map symbol->string args))))

(define (list->symbol . args)
  (string->symbol (apply list->string args)))

(define (symbol . args)
  (string->symbol (apply string args)))


;;; {Lists}
;;;

(define (list-index l k)
  (let loop ((n 0)
	     (l l))
    (and (not (null? l))
	 (if (eq? (car l) k)
	     n
	     (loop (+ n 1) (cdr l))))))

(define (make-list n . init)
  (if (pair? init) (set! init (car init)))
  (let loop ((answer '())
	     (n n))
    (if (<= n 0)
	answer
	(loop (cons init answer) (- n 1)))))


;;; {and-map and or-map}
;;;
;;; (and-map fn lst) is like (and (fn (car lst)) (fn (cadr lst)) (fn...) ...)
;;; (or-map fn lst) is like (or (fn (car lst)) (fn (cadr lst)) (fn...) ...)
;;;

;; and-map f l
;;
;; Apply f to successive elements of l until exhaustion or f returns #f.
;; If returning early, return #f.  Otherwise, return the last value returned
;; by f.  If f has never been called because l is empty, return #t.
;;
(define (and-map f lst)
  (let loop ((result #t)
	     (l lst))
    (and result
	 (or (and (null? l)
		  result)
	     (loop (f (car l)) (cdr l))))))

;; or-map f l
;;
;; Apply f to successive elements of l until exhaustion or while f returns #f.
;; If returning early, return the return value of f.
;;
(define (or-map f lst)
  (let loop ((result #f)
	     (l lst))
    (or result
	(and (not (null? l))
	     (loop (f (car l)) (cdr l))))))



(if (provided? 'posix)
    (primitive-load-path "ice-9/posix.scm"))

(if (provided? 'socket)
    (primitive-load-path "ice-9/networking.scm"))

(define file-exists?
  (if (provided? 'posix)
      (lambda (str)
	(->bool (false-if-exception (stat str))))
      (lambda (str)
	(let ((port (catch 'system-error (lambda () (open-file str OPEN_READ))
			   (lambda args #f))))
	  (if port (begin (close-port port) #t)
	      #f)))))

(define file-is-directory?
  (if (provided? 'posix)
      (lambda (str)
	(eq? (stat:type (stat str)) 'directory))
      (lambda (str)
	(let ((port (catch 'system-error
			   (lambda () (open-file (string-append str "/.")
						 OPEN_READ))
			   (lambda args #f))))
	  (if port (begin (close-port port) #t)
	      #f)))))

(define (has-suffix? str suffix)
  (let ((sufl (string-length suffix))
	(sl (string-length str)))
    (and (> sl sufl)
	 (string=? (substring str (- sl sufl) sl) suffix))))

(define (system-error-errno args)
  (if (eq? (car args) 'system-error)
      (car (list-ref args 4))
      #f))


;;; {Error Handling}
;;;

(define (error . args)
  (save-stack)
  (if (null? args)
      (scm-error 'misc-error #f "?" #f #f)
      (let loop ((msg "~A")
		 (rest (cdr args)))
	(if (not (null? rest))
	    (loop (string-append msg " ~S")
		  (cdr rest))
	    (scm-error 'misc-error #f msg args #f)))))

;; bad-throw is the hook that is called upon a throw to a an unhandled
;; key (unless the throw has four arguments, in which case
;; it's usually interpreted as an error throw.)
;; If the key has a default handler (a throw-handler-default property),
;; it is applied to the throw.
;;
(define (bad-throw key . args)
  (let ((default (symbol-property key 'throw-handler-default)))
    (or (and default (apply default key args))
	(apply error "unhandled-exception:" key args))))



(define (tm:sec obj) (vector-ref obj 0))
(define (tm:min obj) (vector-ref obj 1))
(define (tm:hour obj) (vector-ref obj 2))
(define (tm:mday obj) (vector-ref obj 3))
(define (tm:mon obj) (vector-ref obj 4))
(define (tm:year obj) (vector-ref obj 5))
(define (tm:wday obj) (vector-ref obj 6))
(define (tm:yday obj) (vector-ref obj 7))
(define (tm:isdst obj) (vector-ref obj 8))
(define (tm:gmtoff obj) (vector-ref obj 9))
(define (tm:zone obj) (vector-ref obj 10))

(define (set-tm:sec obj val) (vector-set! obj 0 val))
(define (set-tm:min obj val) (vector-set! obj 1 val))
(define (set-tm:hour obj val) (vector-set! obj 2 val))
(define (set-tm:mday obj val) (vector-set! obj 3 val))
(define (set-tm:mon obj val) (vector-set! obj 4 val))
(define (set-tm:year obj val) (vector-set! obj 5 val))
(define (set-tm:wday obj val) (vector-set! obj 6 val))
(define (set-tm:yday obj val) (vector-set! obj 7 val))
(define (set-tm:isdst obj val) (vector-set! obj 8 val))
(define (set-tm:gmtoff obj val) (vector-set! obj 9 val))
(define (set-tm:zone obj val) (vector-set! obj 10 val))

(define (tms:clock obj) (vector-ref obj 0))
(define (tms:utime obj) (vector-ref obj 1))
(define (tms:stime obj) (vector-ref obj 2))
(define (tms:cutime obj) (vector-ref obj 3))
(define (tms:cstime obj) (vector-ref obj 4))

(define file-position ftell)
(define (file-set-position port offset . whence)
  (let ((whence (if (eq? whence '()) SEEK_SET (car whence))))
    (seek port offset whence)))

(define (move->fdes fd/port fd)
  (cond ((integer? fd/port)
	 (dup->fdes fd/port fd)
	 (close fd/port)
	 fd)
	(else
	 (primitive-move->fdes fd/port fd)
	 (set-port-revealed! fd/port 1)
	 fd/port)))

(define (release-port-handle port)
  (let ((revealed (port-revealed port)))
    (if (> revealed 0)
	(set-port-revealed! port (- revealed 1)))))

(define (dup->port port/fd mode . maybe-fd)
  (let ((port (fdopen (apply dup->fdes port/fd maybe-fd)
		      mode)))
    (if (pair? maybe-fd)
	(set-port-revealed! port 1))
    port))

(define (dup->inport port/fd . maybe-fd)
  (apply dup->port port/fd "r" maybe-fd))

(define (dup->outport port/fd . maybe-fd)
  (apply dup->port port/fd "w" maybe-fd))

(define (dup port/fd . maybe-fd)
  (if (integer? port/fd)
      (apply dup->fdes port/fd maybe-fd)
      (apply dup->port port/fd (port-mode port/fd) maybe-fd)))

(define (duplicate-port port modes)
  (dup->port port modes))

(define (fdes->inport fdes)
  (let loop ((rest-ports (fdes->ports fdes)))
    (cond ((null? rest-ports)
	   (let ((result (fdopen fdes "r")))
	     (set-port-revealed! result 1)
	     result))
	  ((input-port? (car rest-ports))
	   (set-port-revealed! (car rest-ports)
			       (+ (port-revealed (car rest-ports)) 1))
	   (car rest-ports))
	  (else
	   (loop (cdr rest-ports))))))

(define (fdes->outport fdes)
  (let loop ((rest-ports (fdes->ports fdes)))
    (cond ((null? rest-ports)
	   (let ((result (fdopen fdes "w")))
	     (set-port-revealed! result 1)
	     result))
	  ((output-port? (car rest-ports))
	   (set-port-revealed! (car rest-ports)
			       (+ (port-revealed (car rest-ports)) 1))
	   (car rest-ports))
	  (else
	   (loop (cdr rest-ports))))))

(define (port->fdes port)
  (set-port-revealed! port (+ (port-revealed port) 1))
  (fileno port))

(define (setenv name value)
  (if value
      (putenv (string-append name "=" value))
      (putenv name)))


;;; {Load Paths}
;;;

;;; Here for backward compatability
;;
(define scheme-file-suffix (lambda () ".scm"))

(define (in-vicinity vicinity file)
  (let ((tail (let ((len (string-length vicinity)))
		(if (zero? len)
		    #f
		    (string-ref vicinity (- len 1))))))
    (string-append vicinity
		   (if (or (not tail)
			   (eq? tail #\/))
		       ""
		       "/")
		   file)))


;;; {Help for scm_shell}
;;; The argument-processing code used by Guile-based shells generates
;;; Scheme code based on the argument list.  This page contains help
;;; functions for the code it generates.

(define (command-line) (program-arguments))

;; This is mostly for the internal use of the code generated by
;; scm_compile_shell_switches.
(define (load-user-init)
  (let* ((home (or (getenv "HOME")
		   (false-if-exception (passwd:dir (getpwuid (getuid))))
		   "/"))  ;; fallback for cygwin etc.
	 (init-file (in-vicinity home ".guile")))
    (if (file-exists? init-file)
	(primitive-load init-file))))


;;; {Loading by paths}

;;; Load a Scheme source file named NAME, searching for it in the
;;; directories listed in %load-path, and applying each of the file
;;; name extensions listed in %load-extensions.
(define (load-from-path name)
  (start-stack 'load-stack
	       (primitive-load-path name)))



;;; {Transcendental Functions}
;;;
;;; Derived from "Transcen.scm", Complex trancendental functions for SCM.
;;; Written by Jerry D. Hedden, (C) FSF.
;;; See the file `COPYING' for terms applying to this program.
;;;

(define (exp z)
  (if (real? z) ($exp z)
      (make-polar ($exp (real-part z)) (imag-part z))))

(define (log z)
  (if (and (real? z) (>= z 0))
      ($log z)
      (make-rectangular ($log (magnitude z)) (angle z))))

(define (sqrt z)
  (if (real? z)
      (if (negative? z) (make-rectangular 0 ($sqrt (- z)))
	  ($sqrt z))
      (make-polar ($sqrt (magnitude z)) (/ (angle z) 2))))

(define expt
  (let ((integer-expt integer-expt))
    (lambda (z1 z2)
      (cond ((integer? z2)
             (if (negative? z2)
		 (/ 1 (integer-expt z1 (- z2)))
		 (integer-expt z1 z2)))
	    ((and (real? z2) (real? z1) (>= z1 0))
	     ($expt z1 z2))
	    (else
	     (exp (* z2 (log z1))))))))

(define (sinh z)
  (if (real? z) ($sinh z)
      (let ((x (real-part z)) (y (imag-part z)))
	(make-rectangular (* ($sinh x) ($cos y))
			  (* ($cosh x) ($sin y))))))
(define (cosh z)
  (if (real? z) ($cosh z)
      (let ((x (real-part z)) (y (imag-part z)))
	(make-rectangular (* ($cosh x) ($cos y))
			  (* ($sinh x) ($sin y))))))
(define (tanh z)
  (if (real? z) ($tanh z)
      (let* ((x (* 2 (real-part z)))
	     (y (* 2 (imag-part z)))
	     (w (+ ($cosh x) ($cos y))))
	(make-rectangular (/ ($sinh x) w) (/ ($sin y) w)))))

(define (asinh z)
  (if (real? z) ($asinh z)
      (log (+ z (sqrt (+ (* z z) 1))))))

(define (acosh z)
  (if (and (real? z) (>= z 1))
      ($acosh z)
      (log (+ z (sqrt (- (* z z) 1))))))

(define (atanh z)
  (if (and (real? z) (> z -1) (< z 1))
      ($atanh z)
      (/ (log (/ (+ 1 z) (- 1 z))) 2)))

(define (sin z)
  (if (real? z) ($sin z)
      (let ((x (real-part z)) (y (imag-part z)))
	(make-rectangular (* ($sin x) ($cosh y))
			  (* ($cos x) ($sinh y))))))
(define (cos z)
  (if (real? z) ($cos z)
      (let ((x (real-part z)) (y (imag-part z)))
	(make-rectangular (* ($cos x) ($cosh y))
			  (- (* ($sin x) ($sinh y)))))))
(define (tan z)
  (if (real? z) ($tan z)
      (let* ((x (* 2 (real-part z)))
	     (y (* 2 (imag-part z)))
	     (w (+ ($cos x) ($cosh y))))
	(make-rectangular (/ ($sin x) w) (/ ($sinh y) w)))))

(define (asin z)
  (if (and (real? z) (>= z -1) (<= z 1))
      ($asin z)
      (* -i (asinh (* +i z)))))

(define (acos z)
  (if (and (real? z) (>= z -1) (<= z 1))
      ($acos z)
      (+ (/ (angle -1) 2) (* +i (asinh (* +i z))))))

(define (atan z . y)
  (if (null? y)
      (if (real? z) ($atan z)
	  (/ (log (/ (- +i z) (+ +i z))) +2i))
      ($atan2 z (car y))))

(define (log10 arg)
  (/ (log arg) (log 10)))



;;; {Reader Extensions}
;;;

;;; Reader code for various "#c" forms.
;;;

(read-hash-extend #\' (lambda (c port)
			(read port)))

(define read-eval? (make-fluid))
(fluid-set! read-eval? #f)
(read-hash-extend #\.
                  (lambda (c port)
                    (if (fluid-ref read-eval?)
                        (eval (read port) (interaction-environment))
                        (error
                         "#. read expansion found and read-eval? is #f."))))


;;; {Command Line Options}
;;;

(define (get-option argv kw-opts kw-args return)
  (cond
   ((null? argv)
    (return #f #f argv))

   ((or (not (eq? #\- (string-ref (car argv) 0)))
	(eq? (string-length (car argv)) 1))
    (return 'normal-arg (car argv) (cdr argv)))

   ((eq? #\- (string-ref (car argv) 1))
    (let* ((kw-arg-pos (or (string-index (car argv) #\=)
			   (string-length (car argv))))
	   (kw (symbol->keyword (substring (car argv) 2 kw-arg-pos)))
	   (kw-opt? (member kw kw-opts))
	   (kw-arg? (member kw kw-args))
	   (arg (or (and (not (eq? kw-arg-pos (string-length (car argv))))
			 (substring (car argv)
				    (+ kw-arg-pos 1)
				    (string-length (car argv))))
		    (and kw-arg?
			 (begin (set! argv (cdr argv)) (car argv))))))
      (if (or kw-opt? kw-arg?)
	  (return kw arg (cdr argv))
	  (return 'usage-error kw (cdr argv)))))

   (else
    (let* ((char (substring (car argv) 1 2))
	   (kw (symbol->keyword char)))
      (cond

       ((member kw kw-opts)
	(let* ((rest-car (substring (car argv) 2 (string-length (car argv))))
	       (new-argv (if (= 0 (string-length rest-car))
			     (cdr argv)
			     (cons (string-append "-" rest-car) (cdr argv)))))
	  (return kw #f new-argv)))

       ((member kw kw-args)
	(let* ((rest-car (substring (car argv) 2 (string-length (car argv))))
	       (arg (if (= 0 (string-length rest-car))
			(cadr argv)
			rest-car))
	       (new-argv (if (= 0 (string-length rest-car))
			     (cddr argv)
			     (cdr argv))))
	  (return kw arg new-argv)))

       (else (return 'usage-error kw argv)))))))

(define (for-next-option proc argv kw-opts kw-args)
  (let loop ((argv argv))
    (get-option argv kw-opts kw-args
		(lambda (opt opt-arg argv)
		  (and opt (proc opt opt-arg argv loop))))))

(define (display-usage-report kw-desc)
  (for-each
   (lambda (kw)
     (or (eq? (car kw) #t)
	 (eq? (car kw) 'else)
	 (let* ((opt-desc kw)
		(help (cadr opt-desc))
		(opts (car opt-desc))
		(opts-proper (if (string? (car opts)) (cdr opts) opts))
		(arg-name (if (string? (car opts))
			      (string-append "<" (car opts) ">")
			      ""))
		(left-part (string-append
			    (with-output-to-string
			      (lambda ()
				(map (lambda (x) (display (keyword->symbol x)) (display " "))
				     opts-proper)))
			    arg-name))
		(middle-part (if (and (< (string-length left-part) 30)
				      (< (string-length help) 40))
				 (make-string (- 30 (string-length left-part)) #\ )
				 "\n\t")))
	   (display left-part)
	   (display middle-part)
	   (display help)
	   (newline))))
   kw-desc))



(define (transform-usage-lambda cases)
  (let* ((raw-usage (delq! 'else (map car cases)))
	 (usage-sans-specials (map (lambda (x)
				    (or (and (not (list? x)) x)
					(and (symbol? (car x)) #t)
					(and (boolean? (car x)) #t)
					x))
				  raw-usage))
	 (usage-desc (delq! #t usage-sans-specials))
	 (kw-desc (map car usage-desc))
	 (kw-opts (apply append (map (lambda (x) (and (not (string? (car x))) x)) kw-desc)))
	 (kw-args (apply append (map (lambda (x) (and (string? (car x)) (cdr x))) kw-desc)))
	 (transmogrified-cases (map (lambda (case)
				      (cons (let ((opts (car case)))
					      (if (or (boolean? opts) (eq? 'else opts))
						  opts
						  (cond
						   ((symbol? (car opts))  opts)
						   ((boolean? (car opts)) opts)
						   ((string? (caar opts)) (cdar opts))
						   (else (car opts)))))
					    (cdr case)))
				    cases)))
    `(let ((%display-usage (lambda () (display-usage-report ',usage-desc))))
       (lambda (%argv)
	 (let %next-arg ((%argv %argv))
	   (get-option %argv
		       ',kw-opts
		       ',kw-args
		       (lambda (%opt %arg %new-argv)
			 (case %opt
			   ,@ transmogrified-cases))))))))




;;; {Low Level Modules}
;;;
;;; These are the low level data structures for modules.
;;;
;;; !!! warning: The interface to lazy binder procedures is going
;;; to be changed in an incompatible way to permit all the basic
;;; module ops to be virtualized.
;;;
;;; (make-module size use-list lazy-binding-proc) => module
;;; module-{obarray,uses,binder}[|-set!]
;;; (module? obj) => [#t|#f]
;;; (module-locally-bound? module symbol) => [#t|#f]
;;; (module-bound? module symbol) => [#t|#f]
;;; (module-symbol-locally-interned? module symbol) => [#t|#f]
;;; (module-symbol-interned? module symbol) => [#t|#f]
;;; (module-local-variable module symbol) => [#<variable ...> | #f]
;;; (module-variable module symbol) => [#<variable ...> | #f]
;;; (module-symbol-binding module symbol opt-value)
;;;		=> [ <obj> | opt-value | an error occurs ]
;;; (module-make-local-var! module symbol) => #<variable...>
;;; (module-add! module symbol var) => unspecified
;;; (module-remove! module symbol) =>  unspecified
;;; (module-for-each proc module) => unspecified
;;; (make-scm-module) => module ; a lazy copy of the symhash module
;;; (set-current-module module) => unspecified
;;; (current-module) => #<module...>
;;;
;;;


;;; {Printing Modules}
;; This is how modules are printed.  You can re-define it.
;; (Redefining is actually more complicated than simply redefining
;; %print-module because that would only change the binding and not
;; the value stored in the vtable that determines how record are
;; printed. Sigh.)

(define (%print-module mod port)  ; unused args: depth length style table)
  (display "#<" port)
  (display (or (module-kind mod) "module") port)
  (let ((name (module-name mod)))
    (if name
	(begin
	  (display " " port)
	  (display name port))))
  (display " " port)
  (display (number->string (object-address mod) 16) port)
  (display ">" port))

;; module-type
;;
;; A module is characterized by an obarray in which local symbols
;; are interned, a list of modules, "uses", from which non-local
;; bindings can be inherited, and an optional lazy-binder which
;; is a (CLOSURE module symbol) which, as a last resort, can provide
;; bindings that would otherwise not be found locally in the module.
;;
;; NOTE: If you change here, you also need to change libguile/modules.h.
;;
(define module-type
  (make-record-type 'module
		    '(obarray uses binder eval-closure transformer name kind
			      observers weak-observers observer-id)
		    %print-module))

;; make-module &opt size uses binder
;;
;; Create a new module, perhaps with a particular size of obarray,
;; initial uses list, or binding procedure.
;;
(define make-module
    (lambda args

      (define (parse-arg index default)
	(if (> (length args) index)
	    (list-ref args index)
	    default))

      (if (> (length args) 3)
	  (error "Too many args to make-module." args))

      (let ((size (parse-arg 0 1021))
	    (uses (parse-arg 1 '()))
	    (binder (parse-arg 2 #f)))

	(if (not (integer? size))
	    (error "Illegal size to make-module." size))
	(if (not (and (list? uses)
		      (and-map module? uses)))
	    (error "Incorrect use list." uses))
	(if (and binder (not (procedure? binder)))
	    (error
	     "Lazy-binder expected to be a procedure or #f." binder))

	(let ((module (module-constructor (make-vector size '())
					  uses binder #f #f #f #f
					  '()
					  (make-weak-value-hash-table 31)
					  0)))

	  ;; We can't pass this as an argument to module-constructor,
	  ;; because we need it to close over a pointer to the module
	  ;; itself.
	  (set-module-eval-closure! module (standard-eval-closure module))

	  module))))

(define module-constructor (record-constructor module-type))
(define module-obarray  (record-accessor module-type 'obarray))
(define set-module-obarray! (record-modifier module-type 'obarray))
(define module-uses  (record-accessor module-type 'uses))
(define set-module-uses! (record-modifier module-type 'uses))
(define module-binder (record-accessor module-type 'binder))
(define set-module-binder! (record-modifier module-type 'binder))

;; NOTE: This binding is used in libguile/modules.c.
(define module-eval-closure (record-accessor module-type 'eval-closure))

(define module-transformer (record-accessor module-type 'transformer))
(define set-module-transformer! (record-modifier module-type 'transformer))
(define module-name (record-accessor module-type 'name))
(define set-module-name! (record-modifier module-type 'name))
(define module-kind (record-accessor module-type 'kind))
(define set-module-kind! (record-modifier module-type 'kind))
(define module-observers (record-accessor module-type 'observers))
(define set-module-observers! (record-modifier module-type 'observers))
(define module-weak-observers (record-accessor module-type 'weak-observers))
(define module-observer-id (record-accessor module-type 'observer-id))
(define set-module-observer-id! (record-modifier module-type 'observer-id))
(define module? (record-predicate module-type))

(define set-module-eval-closure!
  (let ((setter (record-modifier module-type 'eval-closure)))
    (lambda (module closure)
      (setter module closure)
      ;; Make it possible to lookup the module from the environment.
      ;; This implementation is correct since an eval closure can belong
      ;; to maximally one module.
      (set-procedure-property! closure 'module module))))

(begin-deprecated
 (define (eval-in-module exp mod)
   (issue-deprecation-warning
    "`eval-in-module' is deprecated.  Use `eval' instead.")
   (eval exp mod)))


;;; {Observer protocol}
;;;

(define (module-observe module proc)
  (set-module-observers! module (cons proc (module-observers module)))
  (cons module proc))

(define (module-observe-weak module proc)
  (let ((id (module-observer-id module)))
    (hash-set! (module-weak-observers module) id proc)
    (set-module-observer-id! module (+ 1 id))
    (cons module id)))

(define (module-unobserve token)
  (let ((module (car token))
	(id (cdr token)))
    (if (integer? id)
	(hash-remove! (module-weak-observers module) id)
	(set-module-observers! module (delq1! id (module-observers module)))))
  *unspecified*)

(define (module-modified m)
  (for-each (lambda (proc) (proc m)) (module-observers m))
  (hash-fold (lambda (id proc res) (proc m)) #f (module-weak-observers m)))


;;; {Module Searching in General}
;;;
;;; We sometimes want to look for properties of a symbol
;;; just within the obarray of one module.  If the property
;;; holds, then it is said to hold ``locally'' as in, ``The symbol
;;; DISPLAY is locally rebound in the module `safe-guile'.''
;;;
;;;
;;; Other times, we want to test for a symbol property in the obarray
;;; of M and, if it is not found there, try each of the modules in the
;;; uses list of M.  This is the normal way of testing for some
;;; property, so we state these properties without qualification as
;;; in: ``The symbol 'fnord is interned in module M because it is
;;; interned locally in module M2 which is a member of the uses list
;;; of M.''
;;;

;; module-search fn m
;;
;; return the first non-#f result of FN applied to M and then to
;; the modules in the uses of m, and so on recursively.  If all applications
;; return #f, then so does this function.
;;
(define (module-search fn m v)
  (define (loop pos)
    (and (pair? pos)
	 (or (module-search fn (car pos) v)
	     (loop (cdr pos)))))
  (or (fn m v)
      (loop (module-uses m))))


;;; {Is a symbol bound in a module?}
;;;
;;; Symbol S in Module M is bound if S is interned in M and if the binding
;;; of S in M has been set to some well-defined value.
;;;

;; module-locally-bound? module symbol
;;
;; Is a symbol bound (interned and defined) locally in a given module?
;;
(define (module-locally-bound? m v)
  (let ((var (module-local-variable m v)))
    (and var
	 (variable-bound? var))))

;; module-bound? module symbol
;;
;; Is a symbol bound (interned and defined) anywhere in a given module
;; or its uses?
;;
(define (module-bound? m v)
  (module-search module-locally-bound? m v))

;;; {Is a symbol interned in a module?}
;;;
;;; Symbol S in Module M is interned if S occurs in
;;; of S in M has been set to some well-defined value.
;;;
;;; It is possible to intern a symbol in a module without providing
;;; an initial binding for the corresponding variable.  This is done
;;; with:
;;;       (module-add! module symbol (make-undefined-variable))
;;;
;;; In that case, the symbol is interned in the module, but not
;;; bound there.  The unbound symbol shadows any binding for that
;;; symbol that might otherwise be inherited from a member of the uses list.
;;;

(define (module-obarray-get-handle ob key)
  ((if (symbol? key) hashq-get-handle hash-get-handle) ob key))

(define (module-obarray-ref ob key)
  ((if (symbol? key) hashq-ref hash-ref) ob key))

(define (module-obarray-set! ob key val)
  ((if (symbol? key) hashq-set! hash-set!) ob key val))

(define (module-obarray-remove! ob key)
  ((if (symbol? key) hashq-remove! hash-remove!) ob key))

;; module-symbol-locally-interned? module symbol
;;
;; is a symbol interned (not neccessarily defined) locally in a given module
;; or its uses?  Interned symbols shadow inherited bindings even if
;; they are not themselves bound to a defined value.
;;
(define (module-symbol-locally-interned? m v)
  (not (not (module-obarray-get-handle (module-obarray m) v))))

;; module-symbol-interned? module symbol
;;
;; is a symbol interned (not neccessarily defined) anywhere in a given module
;; or its uses?  Interned symbols shadow inherited bindings even if
;; they are not themselves bound to a defined value.
;;
(define (module-symbol-interned? m v)
  (module-search module-symbol-locally-interned? m v))


;;; {Mapping modules x symbols --> variables}
;;;

;; module-local-variable module symbol
;; return the local variable associated with a MODULE and SYMBOL.
;;
;;; This function is very important. It is the only function that can
;;; return a variable from a module other than the mutators that store
;;; new variables in modules.  Therefore, this function is the location
;;; of the "lazy binder" hack.
;;;
;;; If symbol is defined in MODULE, and if the definition binds symbol
;;; to a variable, return that variable object.
;;;
;;; If the symbols is not found at first, but the module has a lazy binder,
;;; then try the binder.
;;;
;;; If the symbol is not found at all, return #f.
;;;
(define (module-local-variable m v)
;  (caddr
;   (list m v
	 (let ((b (module-obarray-ref (module-obarray m) v)))
	   (or (and (variable? b) b)
	       (and (module-binder m)
		    ((module-binder m) m v #f)))))
;))

;; module-variable module symbol
;;
;; like module-local-variable, except search the uses in the
;; case V is not found in M.
;;
;; NOTE: This function is superseded with C code (see modules.c)
;;;      when using the standard eval closure.
;;
(define (module-variable m v)
  (module-search module-local-variable m v))


;;; {Mapping modules x symbols --> bindings}
;;;
;;; These are similar to the mapping to variables, except that the
;;; variable is dereferenced.
;;;

;; module-symbol-binding module symbol opt-value
;;
;; return the binding of a variable specified by name within
;; a given module, signalling an error if the variable is unbound.
;; If the OPT-VALUE is passed, then instead of signalling an error,
;; return OPT-VALUE.
;;
(define (module-symbol-local-binding m v . opt-val)
  (let ((var (module-local-variable m v)))
    (if var
	(variable-ref var)
	(if (not (null? opt-val))
	    (car opt-val)
	    (error "Locally unbound variable." v)))))

;; module-symbol-binding module symbol opt-value
;;
;; return the binding of a variable specified by name within
;; a given module, signalling an error if the variable is unbound.
;; If the OPT-VALUE is passed, then instead of signalling an error,
;; return OPT-VALUE.
;;
(define (module-symbol-binding m v . opt-val)
  (let ((var (module-variable m v)))
    (if var
	(variable-ref var)
	(if (not (null? opt-val))
	    (car opt-val)
	    (error "Unbound variable." v)))))



;;; {Adding Variables to Modules}
;;;
;;;


;; module-make-local-var! module symbol
;;
;; ensure a variable for V in the local namespace of M.
;; If no variable was already there, then create a new and uninitialzied
;; variable.
;;
(define (module-make-local-var! m v)
  (or (let ((b (module-obarray-ref (module-obarray m) v)))
	(and (variable? b)
	     (begin
	       (module-modified m)
	       b)))
      (and (module-binder m)
	   ((module-binder m) m v #t))
      (begin
	(let ((answer (make-undefined-variable)))
	  (variable-set-name-hint! answer v)
	  (module-obarray-set! (module-obarray m) v answer)
	  (module-modified m)
	  answer))))

;; module-ensure-local-variable! module symbol
;;
;; Ensure that there is a local variable in MODULE for SYMBOL.  If
;; there is no binding for SYMBOL, create a new uninitialized
;; variable.  Return the local variable.
;;
(define (module-ensure-local-variable! module symbol)
  (or (module-local-variable module symbol)
      (let ((var (make-undefined-variable)))
	(variable-set-name-hint! var symbol)
	(module-add! module symbol var)
	var)))

;; module-add! module symbol var
;;
;; ensure a particular variable for V in the local namespace of M.
;;
(define (module-add! m v var)
  (if (not (variable? var))
      (error "Bad variable to module-add!" var))
  (module-obarray-set! (module-obarray m) v var)
  (module-modified m))

;; module-remove!
;;
;; make sure that a symbol is undefined in the local namespace of M.
;;
(define (module-remove! m v)
  (module-obarray-remove!  (module-obarray m) v)
  (module-modified m))

(define (module-clear! m)
  (vector-fill! (module-obarray m) '())
  (module-modified m))

;; MODULE-FOR-EACH -- exported
;;
;; Call PROC on each symbol in MODULE, with arguments of (SYMBOL VARIABLE).
;;
(define (module-for-each proc module)
  (let ((obarray (module-obarray module)))
    (do ((index 0 (+ index 1))
	 (end (vector-length obarray)))
	((= index end))
      (for-each
       (lambda (bucket)
	 (proc (car bucket) (cdr bucket)))
       (vector-ref obarray index)))))


(define (module-map proc module)
  (let* ((obarray (module-obarray module))
	 (end (vector-length obarray)))

    (let loop ((i 0)
	       (answer '()))
      (if (= i end)
	  answer
	  (loop (+ 1 i)
		(append!
		 (map (lambda (bucket)
			(proc (car bucket) (cdr bucket)))
		      (vector-ref obarray i))
		 answer))))))


;;; {Low Level Bootstrapping}
;;;

;; make-root-module

;; A root module uses the pre-modules-obarray as its obarray.  This
;; special obarray accumulates all bindings that have been established
;; before the module system is fully booted.
;;
;; (The obarray continues to be used by code that has been closed over
;;  before the module system has been booted.)

(define (make-root-module)
  (let ((m (make-module 0)))
    (set-module-obarray! m (%get-pre-modules-obarray))
    m))

;; make-scm-module

;; The root interface is a module that uses the same obarray as the
;; root module.  It does not allow new definitions, tho.

(define (make-scm-module)
  (let ((m (make-module 0)))
    (set-module-obarray! m (%get-pre-modules-obarray))
    (set-module-eval-closure! m (standard-interface-eval-closure m))
    m))



;;; {Module-based Loading}
;;;

(define (save-module-excursion thunk)
  (let ((inner-module (current-module))
	(outer-module #f))
    (dynamic-wind (lambda ()
		    (set! outer-module (current-module))
		    (set-current-module inner-module)
		    (set! inner-module #f))
		  thunk
		  (lambda ()
		    (set! inner-module (current-module))
		    (set-current-module outer-module)
		    (set! outer-module #f)))))

(define basic-load load)

(define (load-module filename)
  (save-module-excursion
   (lambda ()
     (let ((oldname (and (current-load-port)
			 (port-filename (current-load-port)))))
       (basic-load (if (and oldname
			    (> (string-length filename) 0)
			    (not (char=? (string-ref filename 0) #\/))
			    (not (string=? (dirname oldname) ".")))
		       (string-append (dirname oldname) "/" filename)
		       filename))))))



;;; {MODULE-REF -- exported}
;;
;; Returns the value of a variable called NAME in MODULE or any of its
;; used modules.  If there is no such variable, then if the optional third
;; argument DEFAULT is present, it is returned; otherwise an error is signaled.
;;
(define (module-ref module name . rest)
  (let ((variable (module-variable module name)))
    (if (and variable (variable-bound? variable))
	(variable-ref variable)
	(if (null? rest)
	    (error "No variable named" name 'in module)
	    (car rest)			; default value
	    ))))

;; MODULE-SET! -- exported
;;
;; Sets the variable called NAME in MODULE (or in a module that MODULE uses)
;; to VALUE; if there is no such variable, an error is signaled.
;;
(define (module-set! module name value)
  (let ((variable (module-variable module name)))
    (if variable
	(variable-set! variable value)
	(error "No variable named" name 'in module))))

;; MODULE-DEFINE! -- exported
;;
;; Sets the variable called NAME in MODULE to VALUE; if there is no such
;; variable, it is added first.
;;
(define (module-define! module name value)
  (let ((variable (module-local-variable module name)))
    (if variable
	(begin
	  (variable-set! variable value)
	  (module-modified module))
	(let ((variable (make-variable value)))
	  (variable-set-name-hint! variable name)
	  (module-add! module name variable)))))

;; MODULE-DEFINED? -- exported
;;
;; Return #t iff NAME is defined in MODULE (or in a module that MODULE
;; uses)
;;
(define (module-defined? module name)
  (let ((variable (module-variable module name)))
    (and variable (variable-bound? variable))))

;; MODULE-USE! module interface
;;
;; Add INTERFACE to the list of interfaces used by MODULE.
;;
(define (module-use! module interface)
  (set-module-uses! module
		    (cons interface (delq! interface (module-uses module))))
  (module-modified module))


;;; {Recursive Namespaces}
;;;
;;;
;;; A hierarchical namespace emerges if we consider some module to be
;;; root, and variables bound to modules as nested namespaces.
;;;
;;; The routines in this file manage variable names in hierarchical namespace.
;;; Each variable name is a list of elements, looked up in successively nested
;;; modules.
;;;
;;;		(nested-ref some-root-module '(foo bar baz))
;;;		=> <value of a variable named baz in the module bound to bar in
;;;		    the module bound to foo in some-root-module>
;;;
;;;
;;; There are:
;;;
;;;	;; a-root is a module
;;;	;; name is a list of symbols
;;;
;;;	nested-ref a-root name
;;;	nested-set! a-root name val
;;;	nested-define! a-root name val
;;;	nested-remove! a-root name
;;;
;;;
;;; (current-module) is a natural choice for a-root so for convenience there are
;;; also:
;;;
;;;	local-ref name		==	nested-ref (current-module) name
;;;	local-set! name val	==	nested-set! (current-module) name val
;;;	local-define! name val	==	nested-define! (current-module) name val
;;;	local-remove! name	==	nested-remove! (current-module) name
;;;


(define (nested-ref root names)
  (let loop ((cur root)
	     (elts names))
    (cond
     ((null? elts)		cur)
     ((not (module? cur))	#f)
     (else (loop (module-ref cur (car elts) #f) (cdr elts))))))

(define (nested-set! root names val)
  (let loop ((cur root)
	     (elts names))
    (if (null? (cdr elts))
	(module-set! cur (car elts) val)
	(loop (module-ref cur (car elts)) (cdr elts)))))

(define (nested-define! root names val)
  (let loop ((cur root)
	     (elts names))
    (if (null? (cdr elts))
	(module-define! cur (car elts) val)
	(loop (module-ref cur (car elts)) (cdr elts)))))

(define (nested-remove! root names)
  (let loop ((cur root)
	     (elts names))
    (if (null? (cdr elts))
	(module-remove! cur (car elts))
	(loop (module-ref cur (car elts)) (cdr elts)))))

(define (local-ref names) (nested-ref (current-module) names))
(define (local-set! names val) (nested-set! (current-module) names val))
(define (local-define names val) (nested-define! (current-module) names val))
(define (local-remove names) (nested-remove! (current-module) names))
;;; boot-9.scm ends here

---tokens---
';;; installed-scm-file' Comment.Single
'\n\n'        Text

';;;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; This program is free software; you can redistribute it and/or modify' Comment.Single
'\n'          Text

';;;; it under the terms of the GNU General Public License as published by' Comment.Single
'\n'          Text

';;;; the Free Software Foundation; either version 2, or (at your option)' Comment.Single
'\n'          Text

';;;; any later version.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; This program is distributed in the hope that it will be useful,' Comment.Single
'\n'          Text

';;;; but WITHOUT ANY WARRANTY; without even the implied warranty of' Comment.Single
'\n'          Text

';;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the' Comment.Single
'\n'          Text

';;;; GNU General Public License for more details.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; You should have received a copy of the GNU General Public License' Comment.Single
'\n'          Text

';;;; along with this software; see the file COPYING.  If not, write to' Comment.Single
'\n'          Text

';;;; the Free Software Foundation, Inc., 59 Temple Place, Suite 330,' Comment.Single
'\n'          Text

';;;; Boston, MA 02111-1307 USA' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; As a special exception, the Free Software Foundation gives permission' Comment.Single
'\n'          Text

';;;; for additional uses of the text contained in its release of GUILE.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; The exception is that, if you link the GUILE library with other files' Comment.Single
'\n'          Text

';;;; to produce an executable, this does not by itself cause the' Comment.Single
'\n'          Text

';;;; resulting executable to be covered by the GNU General Public License.' Comment.Single
'\n'          Text

';;;; Your use of that executable is in no way restricted on account of' Comment.Single
'\n'          Text

';;;; linking the GUILE library code into it.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; This exception does not however invalidate any other reasons why' Comment.Single
'\n'          Text

';;;; the executable file might be covered by the GNU General Public License.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; This exception applies only to the code released by the' Comment.Single
'\n'          Text

';;;; Free Software Foundation under the name GUILE.  If you copy' Comment.Single
'\n'          Text

';;;; code from other Free Software Foundation releases into a copy of' Comment.Single
'\n'          Text

';;;; GUILE, as the General Public License permits, the exception does' Comment.Single
'\n'          Text

';;;; not apply to the code that you add in this way.  To avoid misleading' Comment.Single
'\n'          Text

';;;; anyone as to the status of such modified files, you must delete' Comment.Single
'\n'          Text

';;;; this exception notice from them.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n'          Text

';;;; If you write modifications of your own for GUILE, it is your choice' Comment.Single
'\n'          Text

';;;; whether to permit this exception to apply to your modifications.' Comment.Single
'\n'          Text

';;;; If you do not wish that, delete this exception notice.' Comment.Single
'\n'          Text

';;;;'        Comment.Single
'\n\x0c\n\n'  Text

';;; Commentary:' Comment.Single
'\n\n'        Text

';;; This file is the first thing loaded into Guile.  It adds many mundane' Comment.Single
'\n'          Text

';;; definitions and a few that are interesting.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; The module system (hence the hierarchical namespace) are defined in this' Comment.Single
'\n'          Text

';;; file.'   Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';;; Code:'   Comment.Single
'\n\n\x0c\n'  Text

';;; {Deprecation}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

";; We don't have macros here, but we do want to define" Comment.Single
'\n'          Text

";; `begin-deprecated' early." Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'begin-deprecated' Name.Variable
'\n  '        Text
'('           Punctuation
'procedure->memoizing-macro' Name.Function
'\n   '       Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'exp '        Name.Builtin
'env'         Name.Variable
')'           Punctuation
'\n     '     Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'include-deprecated-features' Name.Function
')'           Punctuation
'\n\t '       Text
'`'           Operator
'('           Punctuation
'begin '      Keyword
',@'          Operator
'('           Punctuation
'cdr '        Name.Builtin
'exp'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'`'           Operator
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Features}' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'provide'     Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'memq '       Name.Builtin
'sym'         Name.Variable
' '           Text
'*features*'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'set! '       Keyword
'*features*'  Name.Variable
' '           Text
'('           Punctuation
'cons '       Name.Builtin
'sym'         Name.Variable
' '           Text
'*features*'  Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; Return #t iff FEATURE is available to this Guile interpreter.' Comment.Single
'\n'          Text

';;; In SLIB, provided? also checks to see if the module is available.' Comment.Single
'\n'          Text

";;; We should do that too, but don't." Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'provided?'   Name.Function
' '           Text
'feature'     Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'memq '       Name.Builtin
'feature'     Name.Variable
' '           Text
'*features*'  Name.Variable
')'           Punctuation
' '           Text
'#t'          Name.Constant
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'begin-deprecated' Name.Function
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'feature?'    Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
'\n    '      Text
'"`feature?\' is deprecated.  Use `provided?\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'provided?'   Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; let format alias simple-format until the more complete version is loaded' Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'format'      Name.Variable
' '           Text
'simple-format' Name.Variable
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {R4RS compliance}' Comment.Single
'\n\n'        Text

'('           Punctuation
'primitive-load-path' Name.Function
' '           Text
'"ice-9/r4rs.scm"' Literal.String
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Simple Debugging Tools}' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n\n\n'      Text

';; peek takes any number of arguments, writes them to the' Comment.Single
'\n'          Text

';; current ouput port, and returns the last argument.' Comment.Single
'\n'          Text

';; It is handy to wrap around an expression to look at' Comment.Single
'\n'          Text

';; a value each time is evaluated, e.g.:' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';;\t(+ 10 (troublesome-fn))' Comment.Single
'\n'          Text

";;\t=> (+ 10 (pk 'troublesome-fn-returned (troublesome-fn)))" Comment.Single
'\n'          Text

';;'          Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'peek'        Name.Function
' '           Text
'.'           Operator
' '           Text
'stuff'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'newline'     Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'display '    Name.Builtin
'";;; "'      Literal.String
')'           Punctuation
'\n  '        Text
'('           Punctuation
'write '      Name.Builtin
'stuff'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'newline'     Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'car '        Name.Builtin
'('           Punctuation
'last-pair'   Name.Function
' '           Text
'stuff'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'pk'          Name.Variable
' '           Text
'peek'        Name.Variable
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'warn'        Name.Function
' '           Text
'.'           Operator
' '           Text
'stuff'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'with-output-to-port' Name.Function
' '           Text
'('           Punctuation
'current-error-port' Name.Function
')'           Punctuation
'\n    '      Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'newline'     Name.Function
')'           Punctuation
'\n      '    Text
'('           Punctuation
'display '    Name.Builtin
'";;; WARNING "' Literal.String
')'           Punctuation
'\n      '    Text
'('           Punctuation
'display '    Name.Builtin
'stuff'       Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'newline'     Name.Function
')'           Punctuation
'\n      '    Text
'('           Punctuation
'car '        Name.Builtin
'('           Punctuation
'last-pair'   Name.Function
' '           Text
'stuff'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Trivial Functions}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'identity'    Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'1'           Literal.Number.Integer
'+'           Name.Variable
' '           Text
'n'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'n'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'1'           Literal.Number.Integer
'-'           Name.Variable
' '           Text
'n'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'n'           Name.Variable
' '           Text
'-1'          Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'and=>'       Name.Function
' '           Text
'value'       Name.Variable
' '           Text
'procedure'   Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'and '        Keyword
'value'       Name.Variable
' '           Text
'('           Punctuation
'procedure'   Name.Function
' '           Text
'value'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'make-hash-table' Name.Function
' '           Text
'k'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'make-vector ' Name.Builtin
'k'           Name.Variable
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'begin-deprecated' Name.Function
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'id'          Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
' '           Text
'"`id\' is deprecated.  Use `identity\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'identity'    Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'-1'          Literal.Number.Integer
'+'           Name.Variable
' '           Text
'n'           Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
' '           Text
'"`-1+\' is deprecated.  Use `1-\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'1'           Literal.Number.Integer
'-'           Name.Variable
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'return-it'   Name.Function
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
' '           Text
'"`return-it\' is deprecated.  Use `noop\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'apply '      Name.Builtin
'noop'        Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; apply-to-args is functionally redundant with apply and, worse,' Comment.Single
'\n'          Text

';;; is less general than apply since it only takes two arguments.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; On the other hand, apply-to-args is a syntacticly convenient way to' Comment.Single
'\n'          Text

';;; perform binding in many circumstances when the "let" family of' Comment.Single
'\n'          Text

";;; of forms don't cut it.  E.g.:" Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;\t(apply-to-args (return-3d-mouse-coords)' Comment.Single
'\n'          Text

';;;\t  (lambda (x y z)' Comment.Single
'\n'          Text

';;;\t\t...))' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'apply-to-args' Name.Function
' '           Text
'args'        Name.Variable
' '           Text
'fn'          Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'apply '      Name.Builtin
'fn'          Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

';;; {Integer Math}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'ipow-by-squaring' Name.Function
' '           Text
'x'           Name.Variable
' '           Text
'k'           Name.Variable
' '           Text
'acc'         Name.Variable
' '           Text
'proc'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond '       Keyword
'('           Punctuation
'('           Punctuation
'zero? '      Name.Builtin
'k'           Name.Variable
')'           Punctuation
' '           Text
'acc'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'('           Punctuation
'= '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'k'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'acc'         Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'else '       Keyword
'('           Punctuation
'ipow-by-squaring' Name.Function
' '           Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'x'           Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n\t\t\t\t'  Text
'('           Punctuation
'quotient '   Name.Builtin
'k'           Name.Variable
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
'\n\t\t\t\t'  Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'even? '      Name.Builtin
'k'           Name.Variable
')'           Punctuation
' '           Text
'acc'         Name.Variable
' '           Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'acc'         Name.Variable
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t'  Text
'proc'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'begin-deprecated' Name.Function
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'string-character-length' Name.Function
' '           Text
's'           Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
' '           Text
'"`string-character-length\' is deprecated.  Use `string-length\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'string-length ' Name.Builtin
's'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'flags'       Name.Function
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
' '           Text
'"`flags\' is deprecated.  Use `logior\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'apply '      Name.Builtin
'logior'      Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Symbol Properties}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'symbol-property' Name.Function
' '           Text
'sym'         Name.Variable
' '           Text
'prop'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'pair'        Name.Function
' '           Text
'('           Punctuation
'assoc '      Name.Builtin
'prop'        Name.Variable
' '           Text
'('           Punctuation
'symbol-pref' Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'pair'        Name.Variable
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'pair'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-symbol-property!' Name.Function
' '           Text
'sym'         Name.Variable
' '           Text
'prop'        Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'pair'        Name.Function
' '           Text
'('           Punctuation
'assoc '      Name.Builtin
'prop'        Name.Variable
' '           Text
'('           Punctuation
'symbol-pref' Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'pair'        Name.Variable
'\n\t'        Text
'('           Punctuation
'set-cdr! '   Name.Builtin
'pair'        Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'symbol-pset!' Name.Function
' '           Text
'sym'         Name.Variable
' '           Text
'('           Punctuation
'acons'       Name.Function
' '           Text
'prop'        Name.Variable
' '           Text
'val'         Name.Variable
' '           Text
'('           Punctuation
'symbol-pref' Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'symbol-property-remove!' Name.Function
' '           Text
'sym'         Name.Variable
' '           Text
'prop'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'pair'        Name.Function
' '           Text
'('           Punctuation
'assoc '      Name.Builtin
'prop'        Name.Variable
' '           Text
'('           Punctuation
'symbol-pref' Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'pair'        Name.Variable
'\n\t'        Text
'('           Punctuation
'symbol-pset!' Name.Function
' '           Text
'sym'         Name.Variable
' '           Text
'('           Punctuation
'delq!'       Name.Function
' '           Text
'pair'        Name.Variable
' '           Text
'('           Punctuation
'symbol-pref' Name.Function
' '           Text
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; {General Properties}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; This is a more modern interface to properties.  It will replace all' Comment.Single
'\n'          Text

';; other property-like things eventually.' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'make-object-property' Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'prop'        Name.Function
' '           Text
'('           Punctuation
'primitive-make-property' Name.Function
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'make-procedure-with-setter' Name.Function
'\n     '     Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'obj'         Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'primitive-property-ref' Name.Function
' '           Text
'prop'        Name.Variable
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n     '     Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'obj'         Name.Function
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'primitive-property-set!' Name.Function
' '           Text
'prop'        Name.Variable
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

';;; {Arrays}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'if '         Keyword
'('           Punctuation
'provided?'   Name.Function
' '           Text
"'array"      Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'primitive-load-path' Name.Function
' '           Text
'"ice-9/arrays.scm"' Literal.String
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Keywords}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'symbol->keyword' Name.Function
' '           Text
'symbol'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'make-keyword-from-dash-symbol' Name.Function
' '           Text
'('           Punctuation
'symbol-append' Name.Function
' '           Text
"'-"          Literal.String.Symbol
' '           Text
'symbol'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'keyword->symbol' Name.Function
' '           Text
'kw'          Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'sym'         Name.Function
' '           Text
'('           Punctuation
'symbol->string ' Name.Builtin
'('           Punctuation
'keyword-dash-symbol' Name.Function
' '           Text
'kw'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'string->symbol ' Name.Builtin
'('           Punctuation
'substring '  Name.Builtin
'sym'         Name.Variable
' '           Text
'1'           Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'sym'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'kw-arg-ref'  Name.Function
' '           Text
'args'        Name.Variable
' '           Text
'kw'          Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'rem'         Name.Function
' '           Text
'('           Punctuation
'member '     Name.Builtin
'kw'          Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'rem'         Name.Variable
' '           Text
'('           Punctuation
'pair? '      Name.Builtin
'('           Punctuation
'cdr '        Name.Builtin
'rem'         Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cadr '       Name.Builtin
'rem'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

';;; {Structs}' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'struct-layout' Name.Function
' '           Text
's'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'struct-ref'  Name.Function
' '           Text
'('           Punctuation
'struct-vtable' Name.Function
' '           Text
's'           Name.Variable
')'           Punctuation
' '           Text
'vtable-index-layout' Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

';;; Environments' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'the-environment' Name.Variable
'\n  '        Text
'('           Punctuation
'procedure->syntax' Name.Function
'\n   '       Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'x'           Name.Function
' '           Text
'e'           Name.Variable
')'           Punctuation
'\n     '     Text
'e'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'the-root-environment' Name.Variable
' '           Text
'('           Punctuation
'the-environment' Name.Function
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'environment-module' Name.Function
' '           Text
'env'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'closure'     Name.Function
' '           Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'pair? '      Name.Builtin
'env'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'car '        Name.Builtin
'('           Punctuation
'last-pair'   Name.Function
' '           Text
'env'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'closure'     Name.Variable
' '           Text
'('           Punctuation
'procedure-property' Name.Function
' '           Text
'closure'     Name.Variable
' '           Text
"'module"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Records}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; Printing records: by default, records are printed as' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';;   #<type-name field1: val1 field2: val2 ...>' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; You can change that by giving a custom printing function to' Comment.Single
'\n'          Text

';; MAKE-RECORD-TYPE (after the list of field symbols).  This function' Comment.Single
'\n'          Text

';; will be called like' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';;   (<printer> object port)' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; It should print OBJECT to PORT.' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'inherit-print-state' Name.Function
' '           Text
'old-port'    Name.Variable
' '           Text
'new-port'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'get-print-state' Name.Function
' '           Text
'old-port'    Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'port-with-print-state' Name.Function
' '           Text
'new-port'    Name.Variable
' '           Text
'('           Punctuation
'get-print-state' Name.Function
' '           Text
'old-port'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'new-port'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; 0: type-name, 1: fields' Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'record-type-vtable' Name.Variable
'\n  '        Text
'('           Punctuation
'make-vtable-vtable' Name.Function
' '           Text
'"prpr"'      Literal.String
' '           Text
'0'           Literal.Number.Integer
'\n\t\t      ' Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
's'           Name.Function
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t'    Text
'('           Punctuation
'cond '       Keyword
'('           Punctuation
'('           Punctuation
'eq? '        Name.Builtin
's'           Name.Variable
' '           Text
'record-type-vtable' Name.Variable
')'           Punctuation
'\n\t\t\t       ' Text
'('           Punctuation
'display '    Name.Builtin
'"#<record-type-vtable>"' Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t      ' Text
'('           Punctuation
'else'        Name.Function
'\n\t\t\t       ' Text
'('           Punctuation
'display '    Name.Builtin
'"#<record-type "' Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t       ' Text
'('           Punctuation
'display '    Name.Builtin
'('           Punctuation
'record-type-name' Name.Function
' '           Text
's'           Name.Variable
')'           Punctuation
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t       ' Text
'('           Punctuation
'display '    Name.Builtin
'">"'         Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-type?' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'struct?'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq? '        Name.Builtin
'record-type-vtable' Name.Variable
' '           Text
'('           Punctuation
'struct-vtable' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'make-record-type' Name.Function
' '           Text
'type-name'   Name.Variable
' '           Text
'fields'      Name.Variable
' '           Text
'.'           Operator
' '           Text
'opt'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'printer-fn'  Name.Function
' '           Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'pair? '      Name.Builtin
'opt'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'car '        Name.Builtin
'opt'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'struct'      Name.Function
' '           Text
'('           Punctuation
'make-struct' Name.Function
' '           Text
'record-type-vtable' Name.Variable
' '           Text
'0'           Literal.Number.Integer
'\n\t\t\t       ' Text
'('           Punctuation
'make-struct-layout' Name.Function
'\n\t\t\t\t'  Text
'('           Punctuation
'apply '      Name.Builtin
'string-append' Name.Variable
'\n\t\t\t\t       ' Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'f'           Name.Function
')'           Punctuation
' '           Text
'"pw"'        Literal.String
')'           Punctuation
' '           Text
'fields'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t       ' Text
'('           Punctuation
'or '         Keyword
'printer-fn'  Name.Variable
'\n\t\t\t\t   ' Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
's'           Name.Function
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t     ' Text
'('           Punctuation
'display '    Name.Builtin
'"#<"'        Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t     ' Text
'('           Punctuation
'display '    Name.Builtin
'type-name'   Name.Variable
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t     ' Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'fields'      Name.Function
' '           Text
'fields'      Name.Variable
')'           Punctuation
'\n\t\t\t\t\t\t' Text
'('           Punctuation
'off'         Name.Function
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t       ' Text
'('           Punctuation
'cond'        Name.Function
'\n\t\t\t\t\t' Text
'('           Punctuation
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'null? '      Name.Builtin
'fields'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t ' Text
'('           Punctuation
'display '    Name.Builtin
'" "'         Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t\t ' Text
'('           Punctuation
'display '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'fields'      Name.Variable
')'           Punctuation
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t\t ' Text
'('           Punctuation
'display '    Name.Builtin
'": "'        Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t\t ' Text
'('           Punctuation
'display '    Name.Builtin
'('           Punctuation
'struct-ref'  Name.Function
' '           Text
's'           Name.Variable
' '           Text
'off'         Name.Variable
')'           Punctuation
' '           Text
'p'           Name.Variable
')'           Punctuation
'\n\t\t\t\t\t ' Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'fields'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'off'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t     ' Text
'('           Punctuation
'display '    Name.Builtin
'">"'         Literal.String
' '           Text
'p'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t       ' Text
'type-name'   Name.Variable
'\n\t\t\t       ' Text
'('           Punctuation
'copy-tree'   Name.Function
' '           Text
'fields'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
';; Temporary solution: Associate a name to the record type descriptor' Comment.Single
'\n      '    Text
';; so that the object system can create a wrapper class for it.' Comment.Single
'\n      '    Text
'('           Punctuation
'set-struct-vtable-name!' Name.Function
' '           Text
'struct'      Name.Variable
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'symbol? '    Name.Builtin
'type-name'   Name.Variable
')'           Punctuation
'\n\t\t\t\t\t  ' Text
'type-name'   Name.Variable
'\n\t\t\t\t\t  ' Text
'('           Punctuation
'string->symbol ' Name.Builtin
'type-name'   Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
'struct'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-type-name' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'record-type?' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'struct-ref'  Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'vtable-offset-user' Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
"'not-a-record-type" Literal.String.Symbol
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-type-fields' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'record-type?' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'struct-ref'  Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'vtable-offset-user' Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
"'not-a-record-type" Literal.String.Symbol
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-constructor' Name.Function
' '           Text
'rtd'         Name.Variable
' '           Text
'.'           Operator
' '           Text
'opt'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'field-names' Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'pair? '      Name.Builtin
'opt'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'car '        Name.Builtin
'opt'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'record-type-fields' Name.Function
' '           Text
'rtd'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'local-eval'  Name.Function
' '           Text
'`'           Operator
'('           Punctuation
'lambda '     Keyword
','           Operator
'field-names' Name.Variable
'\n\t\t   '   Text
'('           Punctuation
'make-struct' Name.Function
' '           Text
"',rtd"       Literal.String.Symbol
' '           Text
'0'           Literal.Number.Integer
' '           Text
',@'          Operator
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'f'           Name.Function
')'           Punctuation
'\n\t\t\t\t\t\t ' Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'memq '       Name.Builtin
'f'           Name.Variable
' '           Text
'field-names' Name.Variable
')'           Punctuation
'\n\t\t\t\t\t\t     ' Text
'f'           Name.Variable
'\n\t\t\t\t\t\t     ' Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t       ' Text
'('           Punctuation
'record-type-fields' Name.Function
' '           Text
'rtd'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'the-root-environment' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-predicate' Name.Function
' '           Text
'rtd'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'obj'         Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'struct?'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq? '        Name.Builtin
'rtd'         Name.Variable
' '           Text
'('           Punctuation
'struct-vtable' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'rtd'         Name.Variable
' '           Text
'field-name'  Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'pos'         Name.Function
' '           Text
'('           Punctuation
'list-index'  Name.Function
' '           Text
'('           Punctuation
'record-type-fields' Name.Function
' '           Text
'rtd'         Name.Variable
')'           Punctuation
' '           Text
'field-name'  Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'pos'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'error'       Name.Function
' '           Text
"'no-such-field" Literal.String.Symbol
' '           Text
'field-name'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'local-eval'  Name.Function
' '           Text
'`'           Operator
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'obj'         Name.Function
')'           Punctuation
'\n\t\t   '   Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'eq? '        Name.Builtin
"',rtd"       Literal.String.Symbol
' '           Text
'('           Punctuation
'record-type-descriptor' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t'    Text
'('           Punctuation
'struct-ref'  Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
','           Operator
'pos'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'the-root-environment' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'rtd'         Name.Variable
' '           Text
'field-name'  Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'pos'         Name.Function
' '           Text
'('           Punctuation
'list-index'  Name.Function
' '           Text
'('           Punctuation
'record-type-fields' Name.Function
' '           Text
'rtd'         Name.Variable
')'           Punctuation
' '           Text
'field-name'  Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'pos'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'error'       Name.Function
' '           Text
"'no-such-field" Literal.String.Symbol
' '           Text
'field-name'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'local-eval'  Name.Function
' '           Text
'`'           Operator
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'obj'         Name.Function
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n\t\t   '   Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'eq? '        Name.Builtin
"',rtd"       Literal.String.Symbol
' '           Text
'('           Punctuation
'record-type-descriptor' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t'    Text
'('           Punctuation
'struct-set!' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
','           Operator
'pos'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'the-root-environment' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n'      Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record?'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'struct?'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'record-type?' Name.Function
' '           Text
'('           Punctuation
'struct-vtable' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'record-type-descriptor' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'struct?'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'struct-vtable' Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
"'not-a-record" Literal.String.Symbol
' '           Text
'obj'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'provide'     Name.Function
' '           Text
"'record"     Literal.String.Symbol
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Booleans}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'->bool'      Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'not '        Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Symbols}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'symbol-append' Name.Function
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'string->symbol ' Name.Builtin
'('           Punctuation
'apply '      Name.Builtin
'string-append' Name.Variable
' '           Text
'('           Punctuation
'map '        Name.Builtin
'symbol->string' Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'list->symbol' Name.Function
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'string->symbol ' Name.Builtin
'('           Punctuation
'apply '      Name.Builtin
'list->string' Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'symbol'      Name.Function
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'string->symbol ' Name.Builtin
'('           Punctuation
'apply '      Name.Builtin
'string'      Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Lists}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'list-index'  Name.Function
' '           Text
'l'           Name.Variable
' '           Text
'k'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'n'           Name.Function
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'l'           Name.Function
' '           Text
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'null? '      Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'eq? '        Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'l'           Name.Variable
')'           Punctuation
' '           Text
'k'           Name.Variable
')'           Punctuation
'\n\t     '   Text
'n'           Name.Variable
'\n\t     '   Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'n'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'make-list'   Name.Function
' '           Text
'n'           Name.Variable
' '           Text
'.'           Operator
' '           Text
'init'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'pair? '      Name.Builtin
'init'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'set! '       Keyword
'init'        Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'init'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'answer'      Name.Function
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'n'           Name.Function
' '           Text
'n'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'<= '         Name.Builtin
'n'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
'\n\t'        Text
'answer'      Name.Variable
'\n\t'        Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'cons '       Name.Builtin
'init'        Name.Variable
' '           Text
'answer'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'- '          Name.Builtin
'n'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {and-map and or-map}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; (and-map fn lst) is like (and (fn (car lst)) (fn (cadr lst)) (fn...) ...)' Comment.Single
'\n'          Text

';;; (or-map fn lst) is like (or (fn (car lst)) (fn (cadr lst)) (fn...) ...)' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; and-map f l' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Apply f to successive elements of l until exhaustion or f returns #f.' Comment.Single
'\n'          Text

';; If returning early, return #f.  Otherwise, return the last value returned' Comment.Single
'\n'          Text

';; by f.  If f has never been called because l is empty, return #t.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'and-map'     Name.Function
' '           Text
'f'           Name.Variable
' '           Text
'lst'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'result'      Name.Function
' '           Text
'#t'          Name.Constant
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'l'           Name.Function
' '           Text
'lst'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'result'      Name.Variable
'\n\t '       Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'null? '      Name.Builtin
'l'           Name.Variable
')'           Punctuation
'\n\t\t  '    Text
'result'      Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'f'           Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; or-map f l' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Apply f to successive elements of l until exhaustion or while f returns #f.' Comment.Single
'\n'          Text

';; If returning early, return the return value of f.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'or-map'      Name.Function
' '           Text
'f'           Name.Variable
' '           Text
'lst'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'result'      Name.Function
' '           Text
'#f'          Name.Constant
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'l'           Name.Function
' '           Text
'lst'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'or '         Keyword
'result'      Name.Variable
'\n\t'        Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'null? '      Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'f'           Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'l'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

'('           Punctuation
'if '         Keyword
'('           Punctuation
'provided?'   Name.Function
' '           Text
"'posix"      Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'primitive-load-path' Name.Function
' '           Text
'"ice-9/posix.scm"' Literal.String
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'if '         Keyword
'('           Punctuation
'provided?'   Name.Function
' '           Text
"'socket"     Literal.String.Symbol
')'           Punctuation
'\n    '      Text
'('           Punctuation
'primitive-load-path' Name.Function
' '           Text
'"ice-9/networking.scm"' Literal.String
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'file-exists?' Name.Variable
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'provided?'   Name.Function
' '           Text
"'posix"      Literal.String.Symbol
')'           Punctuation
'\n      '    Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'str'         Name.Function
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'->bool'      Name.Function
' '           Text
'('           Punctuation
'false-if-exception' Name.Function
' '           Text
'('           Punctuation
'stat'        Name.Function
' '           Text
'str'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'str'         Name.Function
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'port'        Name.Function
' '           Text
'('           Punctuation
'catch'       Name.Function
' '           Text
"'system-error" Literal.String.Symbol
' '           Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'open-file'   Name.Function
' '           Text
'str'         Name.Variable
' '           Text
'OPEN_READ'   Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t   ' Text
'('           Punctuation
'lambda '     Keyword
'args'        Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'if '         Keyword
'port'        Name.Variable
' '           Text
'('           Punctuation
'begin '      Keyword
'('           Punctuation
'close-port'  Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
' '           Text
'#t'          Name.Constant
')'           Punctuation
'\n\t      '  Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'file-is-directory?' Name.Variable
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'provided?'   Name.Function
' '           Text
"'posix"      Literal.String.Symbol
')'           Punctuation
'\n      '    Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'str'         Name.Function
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'eq? '        Name.Builtin
'('           Punctuation
'stat:type'   Name.Function
' '           Text
'('           Punctuation
'stat'        Name.Function
' '           Text
'str'         Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
"'directory"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'str'         Name.Function
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'port'        Name.Function
' '           Text
'('           Punctuation
'catch'       Name.Function
' '           Text
"'system-error" Literal.String.Symbol
'\n\t\t\t   ' Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'open-file'   Name.Function
' '           Text
'('           Punctuation
'string-append ' Name.Builtin
'str'         Name.Variable
' '           Text
'"/."'        Literal.String
')'           Punctuation
'\n\t\t\t\t\t\t ' Text
'OPEN_READ'   Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t   ' Text
'('           Punctuation
'lambda '     Keyword
'args'        Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'if '         Keyword
'port'        Name.Variable
' '           Text
'('           Punctuation
'begin '      Keyword
'('           Punctuation
'close-port'  Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
' '           Text
'#t'          Name.Constant
')'           Punctuation
'\n\t      '  Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'has-suffix?' Name.Function
' '           Text
'str'         Name.Variable
' '           Text
'suffix'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'sufl'        Name.Function
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'suffix'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'sl'          Name.Function
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'str'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'> '          Name.Builtin
'sl'          Name.Variable
' '           Text
'sufl'        Name.Variable
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'string=? '   Name.Builtin
'('           Punctuation
'substring '  Name.Builtin
'str'         Name.Variable
' '           Text
'('           Punctuation
'- '          Name.Builtin
'sl'          Name.Variable
' '           Text
'sufl'        Name.Variable
')'           Punctuation
' '           Text
'sl'          Name.Variable
')'           Punctuation
' '           Text
'suffix'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'system-error-errno' Name.Function
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'eq? '        Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'args'        Name.Variable
')'           Punctuation
' '           Text
"'system-error" Literal.String.Symbol
')'           Punctuation
'\n      '    Text
'('           Punctuation
'car '        Name.Builtin
'('           Punctuation
'list-ref '   Name.Builtin
'args'        Name.Variable
' '           Text
'4'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n      '    Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Error Handling}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'error'       Name.Function
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'save-stack'  Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'null? '      Name.Builtin
'args'        Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'scm-error'   Name.Function
' '           Text
"'misc-error" Literal.String.Symbol
' '           Text
'#f'          Name.Constant
' '           Text
'"?"'         Literal.String
' '           Text
'#f'          Name.Constant
' '           Text
'#f'          Name.Constant
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'msg'         Name.Function
' '           Text
'"~A"'        Literal.String
')'           Punctuation
'\n\t\t '     Text
'('           Punctuation
'rest'        Name.Function
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'null? '      Name.Builtin
'rest'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'string-append ' Name.Builtin
'msg'         Name.Variable
' '           Text
'" ~S"'       Literal.String
')'           Punctuation
'\n\t\t  '    Text
'('           Punctuation
'cdr '        Name.Builtin
'rest'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'scm-error'   Name.Function
' '           Text
"'misc-error" Literal.String.Symbol
' '           Text
'#f'          Name.Constant
' '           Text
'msg'         Name.Variable
' '           Text
'args'        Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; bad-throw is the hook that is called upon a throw to a an unhandled' Comment.Single
'\n'          Text

';; key (unless the throw has four arguments, in which case' Comment.Single
'\n'          Text

";; it's usually interpreted as an error throw.)" Comment.Single
'\n'          Text

';; If the key has a default handler (a throw-handler-default property),' Comment.Single
'\n'          Text

';; it is applied to the throw.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'bad-throw'   Name.Function
' '           Text
'key'         Name.Variable
' '           Text
'.'           Operator
' '           Text
'args'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'default'     Name.Function
' '           Text
'('           Punctuation
'symbol-property' Name.Function
' '           Text
'key'         Name.Variable
' '           Text
"'throw-handler-default" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'and '        Keyword
'default'     Name.Variable
' '           Text
'('           Punctuation
'apply '      Name.Builtin
'default'     Name.Variable
' '           Text
'key'         Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'apply '      Name.Builtin
'error'       Name.Variable
' '           Text
'"unhandled-exception:"' Literal.String
' '           Text
'key'         Name.Variable
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:sec'      Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:min'      Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:hour'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:mday'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'3'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:mon'      Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'4'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:year'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'5'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:wday'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'6'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:yday'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'7'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:isdst'    Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'8'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:gmtoff'   Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'9'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tm:zone'     Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'10'          Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:sec'  Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:min'  Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'1'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:hour' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'2'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:mday' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'3'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:mon'  Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'4'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:year' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'5'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:wday' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'6'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:yday' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'7'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:isdst' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'8'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:gmtoff' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'9'           Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'set-tm:zone' Name.Function
' '           Text
'obj'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-set! ' Name.Builtin
'obj'         Name.Variable
' '           Text
'10'          Literal.Number.Integer
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tms:clock'   Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tms:utime'   Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tms:stime'   Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tms:cutime'  Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'3'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tms:cstime'  Name.Function
' '           Text
'obj'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obj'         Name.Variable
' '           Text
'4'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'file-position' Name.Variable
' '           Text
'ftell'       Name.Variable
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'file-set-position' Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'offset'      Name.Variable
' '           Text
'.'           Operator
' '           Text
'whence'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'whence'      Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'eq? '        Name.Builtin
'whence'      Name.Variable
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'SEEK_SET'    Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'whence'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'seek'        Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'offset'      Name.Variable
' '           Text
'whence'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'move->fdes'  Name.Function
' '           Text
'fd/port'     Name.Variable
' '           Text
'fd'          Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond '       Keyword
'('           Punctuation
'('           Punctuation
'integer? '   Name.Builtin
'fd/port'     Name.Variable
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'dup->fdes'   Name.Function
' '           Text
'fd/port'     Name.Variable
' '           Text
'fd'          Name.Variable
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'close'       Name.Function
' '           Text
'fd/port'     Name.Variable
')'           Punctuation
'\n\t '       Text
'fd'          Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'else'        Name.Function
'\n\t '       Text
'('           Punctuation
'primitive-move->fdes' Name.Function
' '           Text
'fd/port'     Name.Variable
' '           Text
'fd'          Name.Variable
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'fd/port'     Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
'\n\t '       Text
'fd/port'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'release-port-handle' Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'revealed'    Name.Function
' '           Text
'('           Punctuation
'port-revealed' Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'> '          Name.Builtin
'revealed'    Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'('           Punctuation
'- '          Name.Builtin
'revealed'    Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'dup->port'   Name.Function
' '           Text
'port/fd'     Name.Variable
' '           Text
'mode'        Name.Variable
' '           Text
'.'           Operator
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'port'        Name.Function
' '           Text
'('           Punctuation
'fdopen'      Name.Function
' '           Text
'('           Punctuation
'apply '      Name.Builtin
'dup->fdes'   Name.Variable
' '           Text
'port/fd'     Name.Variable
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
'\n\t\t      ' Text
'mode'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'pair? '      Name.Builtin
'maybe-fd'    Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n    '      Text
'port'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'dup->inport' Name.Function
' '           Text
'port/fd'     Name.Variable
' '           Text
'.'           Operator
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'apply '      Name.Builtin
'dup->port'   Name.Variable
' '           Text
'port/fd'     Name.Variable
' '           Text
'"r"'         Literal.String
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'dup->outport' Name.Function
' '           Text
'port/fd'     Name.Variable
' '           Text
'.'           Operator
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'apply '      Name.Builtin
'dup->port'   Name.Variable
' '           Text
'port/fd'     Name.Variable
' '           Text
'"w"'         Literal.String
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'dup'         Name.Function
' '           Text
'port/fd'     Name.Variable
' '           Text
'.'           Operator
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'integer? '   Name.Builtin
'port/fd'     Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'apply '      Name.Builtin
'dup->fdes'   Name.Variable
' '           Text
'port/fd'     Name.Variable
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'apply '      Name.Builtin
'dup->port'   Name.Variable
' '           Text
'port/fd'     Name.Variable
' '           Text
'('           Punctuation
'port-mode'   Name.Function
' '           Text
'port/fd'     Name.Variable
')'           Punctuation
' '           Text
'maybe-fd'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'duplicate-port' Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'modes'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'dup->port'   Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'modes'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'fdes->inport' Name.Function
' '           Text
'fdes'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'rest-ports'  Name.Function
' '           Text
'('           Punctuation
'fdes->ports' Name.Function
' '           Text
'fdes'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'cond '       Keyword
'('           Punctuation
'('           Punctuation
'null? '      Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'result'      Name.Function
' '           Text
'('           Punctuation
'fdopen'      Name.Function
' '           Text
'fdes'        Name.Variable
' '           Text
'"r"'         Literal.String
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'result'      Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
'\n\t     '   Text
'result'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'('           Punctuation
'input-port? ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
'\n\t\t\t       ' Text
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'port-revealed' Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'else'        Name.Function
'\n\t   '     Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'fdes->outport' Name.Function
' '           Text
'fdes'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'rest-ports'  Name.Function
' '           Text
'('           Punctuation
'fdes->ports' Name.Function
' '           Text
'fdes'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'cond '       Keyword
'('           Punctuation
'('           Punctuation
'null? '      Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'result'      Name.Function
' '           Text
'('           Punctuation
'fdopen'      Name.Function
' '           Text
'fdes'        Name.Variable
' '           Text
'"w"'         Literal.String
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'result'      Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
'\n\t     '   Text
'result'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'('           Punctuation
'output-port? ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
'\n\t\t\t       ' Text
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'port-revealed' Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'car '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'else'        Name.Function
'\n\t   '     Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'rest-ports'  Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'port->fdes'  Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'set-port-revealed!' Name.Function
' '           Text
'port'        Name.Variable
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'port-revealed' Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'fileno'      Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'setenv'      Name.Function
' '           Text
'name'        Name.Variable
' '           Text
'value'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'value'       Name.Variable
'\n      '    Text
'('           Punctuation
'putenv'      Name.Function
' '           Text
'('           Punctuation
'string-append ' Name.Builtin
'name'        Name.Variable
' '           Text
'"="'         Literal.String
' '           Text
'value'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'putenv'      Name.Function
' '           Text
'name'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Load Paths}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';;; Here for backward compatability' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'scheme-file-suffix' Name.Variable
' '           Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
' '           Text
'".scm"'      Literal.String
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'in-vicinity' Name.Function
' '           Text
'vicinity'    Name.Variable
' '           Text
'file'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'tail'        Name.Function
' '           Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'len'         Name.Function
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'vicinity'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'zero? '      Name.Builtin
'len'         Name.Variable
')'           Punctuation
'\n\t\t    '  Text
'#f'          Name.Constant
'\n\t\t    '  Text
'('           Punctuation
'string-ref ' Name.Builtin
'vicinity'    Name.Variable
' '           Text
'('           Punctuation
'- '          Name.Builtin
'len'         Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'string-append ' Name.Builtin
'vicinity'    Name.Variable
'\n\t\t   '   Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'or '         Keyword
'('           Punctuation
'not '        Name.Builtin
'tail'        Name.Variable
')'           Punctuation
'\n\t\t\t   ' Text
'('           Punctuation
'eq? '        Name.Builtin
'tail'        Name.Variable
' '           Text
'#\\/'        Literal.String.Char
')'           Punctuation
')'           Punctuation
'\n\t\t       ' Text
'""'          Literal.String
'\n\t\t       ' Text
'"/"'         Literal.String
')'           Punctuation
'\n\t\t   '   Text
'file'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Help for scm_shell}' Comment.Single
'\n'          Text

';;; The argument-processing code used by Guile-based shells generates' Comment.Single
'\n'          Text

';;; Scheme code based on the argument list.  This page contains help' Comment.Single
'\n'          Text

';;; functions for the code it generates.' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'command-line' Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'program-arguments' Name.Function
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; This is mostly for the internal use of the code generated by' Comment.Single
'\n'          Text

';; scm_compile_shell_switches.' Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'load-user-init' Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'home'        Name.Function
' '           Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'getenv'      Name.Function
' '           Text
'"HOME"'      Literal.String
')'           Punctuation
'\n\t\t   '   Text
'('           Punctuation
'false-if-exception' Name.Function
' '           Text
'('           Punctuation
'passwd:dir'  Name.Function
' '           Text
'('           Punctuation
'getpwuid'    Name.Function
' '           Text
'('           Punctuation
'getuid'      Name.Function
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t   '   Text
'"/"'         Literal.String
')'           Punctuation
')'           Punctuation
'  '          Text
';; fallback for cygwin etc.' Comment.Single
'\n\t '       Text
'('           Punctuation
'init-file'   Name.Function
' '           Text
'('           Punctuation
'in-vicinity' Name.Function
' '           Text
'home'        Name.Variable
' '           Text
'".guile"'    Literal.String
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'file-exists?' Name.Function
' '           Text
'init-file'   Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'primitive-load' Name.Function
' '           Text
'init-file'   Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Loading by paths}' Comment.Single
'\n\n'        Text

';;; Load a Scheme source file named NAME, searching for it in the' Comment.Single
'\n'          Text

';;; directories listed in %load-path, and applying each of the file' Comment.Single
'\n'          Text

';;; name extensions listed in %load-extensions.' Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'load-from-path' Name.Function
' '           Text
'name'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'start-stack' Name.Function
' '           Text
"'load-stack" Literal.String.Symbol
'\n\t       ' Text
'('           Punctuation
'primitive-load-path' Name.Function
' '           Text
'name'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n\x0c\n' Text

';;; {Transcendental Functions}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; Derived from "Transcen.scm", Complex trancendental functions for SCM.' Comment.Single
'\n'          Text

';;; Written by Jerry D. Hedden, (C) FSF.' Comment.Single
'\n'          Text

";;; See the file `COPYING' for terms applying to this program." Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'exp '        Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$exp'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'make-polar ' Name.Builtin
'('           Punctuation
'$exp'        Name.Function
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'log '        Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>= '         Name.Builtin
'z'           Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'$log'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'$log'        Name.Function
' '           Text
'('           Punctuation
'magnitude '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'angle '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'sqrt '       Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'negative? '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
'$sqrt'       Name.Function
' '           Text
'('           Punctuation
'- '          Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'$sqrt'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'make-polar ' Name.Builtin
'('           Punctuation
'$sqrt'       Name.Function
' '           Text
'('           Punctuation
'magnitude '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'angle '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'expt'        Name.Variable
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'integer-expt' Name.Function
' '           Text
'integer-expt' Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'z1'          Name.Function
' '           Text
'z2'          Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'cond '       Keyword
'('           Punctuation
'('           Punctuation
'integer? '   Name.Builtin
'z2'          Name.Variable
')'           Punctuation
'\n             ' Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'negative? '  Name.Builtin
'z2'          Name.Variable
')'           Punctuation
'\n\t\t '     Text
'('           Punctuation
'/ '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'('           Punctuation
'integer-expt' Name.Function
' '           Text
'z1'          Name.Variable
' '           Text
'('           Punctuation
'- '          Name.Builtin
'z2'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t '     Text
'('           Punctuation
'integer-expt' Name.Function
' '           Text
'z1'          Name.Variable
' '           Text
'z2'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'('           Punctuation
'and '        Keyword
'('           Punctuation
'real? '      Name.Builtin
'z2'          Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'real? '      Name.Builtin
'z1'          Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>= '         Name.Builtin
'z1'          Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'$expt'       Name.Function
' '           Text
'z1'          Name.Variable
' '           Text
'z2'          Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'else'        Name.Function
'\n\t     '   Text
'('           Punctuation
'exp '        Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'z2'          Name.Variable
' '           Text
'('           Punctuation
'log '        Name.Builtin
'z1'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'sinh'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'x'           Name.Function
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'y'           Name.Function
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cos'        Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t  '  Text
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$sin'        Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'cosh'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'x'           Name.Function
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'y'           Name.Function
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cos'        Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t  '  Text
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$sin'        Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tanh'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$tanh'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'x'           Name.Function
' '           Text
'('           Punctuation
'* '          Name.Builtin
'2'           Literal.Number.Integer
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'y'           Name.Function
' '           Text
'('           Punctuation
'* '          Name.Builtin
'2'           Literal.Number.Integer
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'w'           Name.Function
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cos'        Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'w'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'$sin'        Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'w'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'asinh'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$asinh'      Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'log '        Name.Builtin
'('           Punctuation
'+ '          Name.Builtin
'z'           Name.Variable
' '           Text
'('           Punctuation
'sqrt '       Name.Builtin
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'z'           Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'acosh'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>= '         Name.Builtin
'z'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'$acosh'      Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'log '        Name.Builtin
'('           Punctuation
'+ '          Name.Builtin
'z'           Name.Variable
' '           Text
'('           Punctuation
'sqrt '       Name.Builtin
'('           Punctuation
'- '          Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'z'           Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'atanh'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'> '          Name.Builtin
'z'           Name.Variable
' '           Text
'-1'          Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'< '          Name.Builtin
'z'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'$atanh'      Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'log '        Name.Builtin
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'+ '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'- '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'sin '        Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$sin'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'x'           Name.Function
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'y'           Name.Function
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$sin'        Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t  '  Text
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$cos'        Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'cos '        Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cos'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'x'           Name.Function
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'y'           Name.Function
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$cos'        Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t  '  Text
'('           Punctuation
'- '          Name.Builtin
'('           Punctuation
'* '          Name.Builtin
'('           Punctuation
'$sin'        Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'tan '        Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$tan'        Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'x'           Name.Function
' '           Text
'('           Punctuation
'* '          Name.Builtin
'2'           Literal.Number.Integer
' '           Text
'('           Punctuation
'real-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'y'           Name.Function
' '           Text
'('           Punctuation
'* '          Name.Builtin
'2'           Literal.Number.Integer
' '           Text
'('           Punctuation
'imag-part '  Name.Builtin
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'w'           Name.Function
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'$cos'        Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$cosh'       Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'make-rectangular ' Name.Builtin
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'$sin'        Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
' '           Text
'w'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'$sinh'       Name.Function
' '           Text
'y'           Name.Variable
')'           Punctuation
' '           Text
'w'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'asin '       Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>= '         Name.Builtin
'z'           Name.Variable
' '           Text
'-1'          Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'<= '         Name.Builtin
'z'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'$asin'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'* '          Name.Builtin
'-i'          Name.Variable
' '           Text
'('           Punctuation
'asinh'       Name.Function
' '           Text
'('           Punctuation
'* '          Name.Builtin
'+i'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'acos '       Name.Builtin
'z'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'>= '         Name.Builtin
'z'           Name.Variable
' '           Text
'-1'          Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'<= '         Name.Builtin
'z'           Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'$acos'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'+ '          Name.Builtin
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'angle '      Name.Builtin
'-1'          Literal.Number.Integer
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
' '           Text
'('           Punctuation
'* '          Name.Builtin
'+i'          Name.Variable
' '           Text
'('           Punctuation
'asinh'       Name.Function
' '           Text
'('           Punctuation
'* '          Name.Builtin
'+i'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'atan '       Name.Builtin
'z'           Name.Variable
' '           Text
'.'           Operator
' '           Text
'y'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'null? '      Name.Builtin
'y'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'real? '      Name.Builtin
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'$atan'       Name.Function
' '           Text
'z'           Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'log '        Name.Builtin
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'- '          Name.Builtin
'+i'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'+i'          Name.Variable
' '           Text
'z'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'+2i'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'$atan2'      Name.Function
' '           Text
'z'           Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'y'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'log10'       Name.Function
' '           Text
'arg'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'/ '          Name.Builtin
'('           Punctuation
'log '        Name.Builtin
'arg'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'log '        Name.Builtin
'10'          Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n\n' Text

';;; {Reader Extensions}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';;; Reader code for various "#c" forms.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'read-hash-extend' Name.Function
' '           Text
"#\\'"        Literal.String.Char
' '           Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'c'           Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n\t\t\t'    Text
'('           Punctuation
'read '       Name.Builtin
'port'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'read-eval?'  Name.Variable
' '           Text
'('           Punctuation
'make-fluid'  Name.Function
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'fluid-set!'  Name.Function
' '           Text
'read-eval?'  Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
'\n'          Text

'('           Punctuation
'read-hash-extend' Name.Function
' '           Text
'#\\.'        Literal.String.Char
'\n                  ' Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'c'           Name.Function
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n                    ' Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'fluid-ref'   Name.Function
' '           Text
'read-eval?'  Name.Variable
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'eval '       Name.Builtin
'('           Punctuation
'read '       Name.Builtin
'port'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'interaction-environment' Name.Function
')'           Punctuation
')'           Punctuation
'\n                        ' Text
'('           Punctuation
'error'       Name.Function
'\n                         ' Text
'"#. read expansion found and read-eval? is #f."' Literal.String
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Command Line Options}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'get-option'  Name.Function
' '           Text
'argv'        Name.Variable
' '           Text
'kw-opts'     Name.Variable
' '           Text
'kw-args'     Name.Variable
' '           Text
'return'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cond'        Name.Function
'\n   '       Text
'('           Punctuation
'('           Punctuation
'null? '      Name.Builtin
'argv'        Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'return'      Name.Function
' '           Text
'#f'          Name.Constant
' '           Text
'#f'          Name.Constant
' '           Text
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n   '     Text
'('           Punctuation
'('           Punctuation
'or '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'eq? '        Name.Builtin
'#\\-'        Literal.String.Char
' '           Text
'('           Punctuation
'string-ref ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'eq? '        Name.Builtin
'('           Punctuation
'string-length ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'return'      Name.Function
' '           Text
"'normal-arg" Literal.String.Symbol
' '           Text
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n   '     Text
'('           Punctuation
'('           Punctuation
'eq? '        Name.Builtin
'#\\-'        Literal.String.Char
' '           Text
'('           Punctuation
'string-ref ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'kw-arg-pos'  Name.Function
' '           Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'string-index' Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'#\\='        Literal.String.Char
')'           Punctuation
'\n\t\t\t   ' Text
'('           Punctuation
'string-length ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'kw'          Name.Function
' '           Text
'('           Punctuation
'symbol->keyword' Name.Function
' '           Text
'('           Punctuation
'substring '  Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
' '           Text
'kw-arg-pos'  Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'kw-opt?'     Name.Function
' '           Text
'('           Punctuation
'member '     Name.Builtin
'kw'          Name.Variable
' '           Text
'kw-opts'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'kw-arg?'     Name.Function
' '           Text
'('           Punctuation
'member '     Name.Builtin
'kw'          Name.Variable
' '           Text
'kw-args'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'arg'         Name.Function
' '           Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'eq? '        Name.Builtin
'kw-arg-pos'  Name.Variable
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t '   Text
'('           Punctuation
'substring '  Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
'\n\t\t\t\t    ' Text
'('           Punctuation
'+ '          Name.Builtin
'kw-arg-pos'  Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
'\n\t\t\t\t    ' Text
'('           Punctuation
'string-length ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'and '        Keyword
'kw-arg?'     Name.Variable
'\n\t\t\t '   Text
'('           Punctuation
'begin '      Keyword
'('           Punctuation
'set! '       Keyword
'argv'        Name.Variable
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'or '         Keyword
'kw-opt?'     Name.Variable
' '           Text
'kw-arg?'     Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'return'      Name.Function
' '           Text
'kw'          Name.Variable
' '           Text
'arg'         Name.Variable
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'return'      Name.Function
' '           Text
"'usage-error" Literal.String.Symbol
' '           Text
'kw'          Name.Variable
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n   '     Text
'('           Punctuation
'else'        Name.Function
'\n    '      Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'char'        Name.Function
' '           Text
'('           Punctuation
'substring '  Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'1'           Literal.Number.Integer
' '           Text
'2'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'kw'          Name.Function
' '           Text
'('           Punctuation
'symbol->keyword' Name.Function
' '           Text
'char'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'cond'        Name.Function
'\n\n       ' Text
'('           Punctuation
'('           Punctuation
'member '     Name.Builtin
'kw'          Name.Variable
' '           Text
'kw-opts'     Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'rest-car'    Name.Function
' '           Text
'('           Punctuation
'substring '  Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t       ' Text
'('           Punctuation
'new-argv'    Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'= '          Name.Builtin
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'rest-car'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t     ' Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
'\n\t\t\t     ' Text
'('           Punctuation
'cons '       Name.Builtin
'('           Punctuation
'string-append ' Name.Builtin
'"-"'         Literal.String
' '           Text
'rest-car'    Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'return'      Name.Function
' '           Text
'kw'          Name.Variable
' '           Text
'#f'          Name.Constant
' '           Text
'new-argv'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n       ' Text
'('           Punctuation
'('           Punctuation
'member '     Name.Builtin
'kw'          Name.Variable
' '           Text
'kw-args'     Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'rest-car'    Name.Function
' '           Text
'('           Punctuation
'substring '  Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
' '           Text
'2'           Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t       ' Text
'('           Punctuation
'arg'         Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'= '          Name.Builtin
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'rest-car'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t'    Text
'('           Punctuation
'cadr '       Name.Builtin
'argv'        Name.Variable
')'           Punctuation
'\n\t\t\t'    Text
'rest-car'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t       ' Text
'('           Punctuation
'new-argv'    Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'= '          Name.Builtin
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'rest-car'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t     ' Text
'('           Punctuation
'cddr '       Name.Builtin
'argv'        Name.Variable
')'           Punctuation
'\n\t\t\t     ' Text
'('           Punctuation
'cdr '        Name.Builtin
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'return'      Name.Function
' '           Text
'kw'          Name.Variable
' '           Text
'arg'         Name.Variable
' '           Text
'new-argv'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n       ' Text
'('           Punctuation
'else '       Keyword
'('           Punctuation
'return'      Name.Function
' '           Text
"'usage-error" Literal.String.Symbol
' '           Text
'kw'          Name.Variable
' '           Text
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'for-next-option' Name.Function
' '           Text
'proc'        Name.Variable
' '           Text
'argv'        Name.Variable
' '           Text
'kw-opts'     Name.Variable
' '           Text
'kw-args'     Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'argv'        Name.Function
' '           Text
'argv'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'get-option'  Name.Function
' '           Text
'argv'        Name.Variable
' '           Text
'kw-opts'     Name.Variable
' '           Text
'kw-args'     Name.Variable
'\n\t\t'      Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'opt'         Name.Function
' '           Text
'opt-arg'     Name.Variable
' '           Text
'argv'        Name.Variable
')'           Punctuation
'\n\t\t  '    Text
'('           Punctuation
'and '        Keyword
'opt'         Name.Variable
' '           Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'opt'         Name.Variable
' '           Text
'opt-arg'     Name.Variable
' '           Text
'argv'        Name.Variable
' '           Text
'loop'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'display-usage-report' Name.Function
' '           Text
'kw-desc'     Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'for-each'    Name.Function
'\n   '       Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'kw'          Name.Function
')'           Punctuation
'\n     '     Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'eq? '        Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'kw'          Name.Variable
')'           Punctuation
' '           Text
'#t'          Name.Constant
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'eq? '        Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'kw'          Name.Variable
')'           Punctuation
' '           Text
"'else"       Literal.String.Symbol
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'opt-desc'    Name.Function
' '           Text
'kw'          Name.Variable
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'help'        Name.Function
' '           Text
'('           Punctuation
'cadr '       Name.Builtin
'opt-desc'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'opts'        Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'opt-desc'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'opts-proper' Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'string? '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
' '           Text
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'arg-name'    Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'string? '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t      ' Text
'('           Punctuation
'string-append ' Name.Builtin
'"<"'         Literal.String
' '           Text
'('           Punctuation
'car '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
' '           Text
'">"'         Literal.String
')'           Punctuation
'\n\t\t\t      ' Text
'""'          Literal.String
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'left-part'   Name.Function
' '           Text
'('           Punctuation
'string-append' Name.Function
'\n\t\t\t    ' Text
'('           Punctuation
'with-output-to-string' Name.Function
'\n\t\t\t      ' Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
'\n\t\t\t\t'  Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'x'           Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'display '    Name.Builtin
'('           Punctuation
'keyword->symbol' Name.Function
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'display '    Name.Builtin
'" "'         Literal.String
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t     ' Text
'opts-proper' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t    ' Text
'arg-name'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'middle-part' Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'< '          Name.Builtin
'('           Punctuation
'string-length ' Name.Builtin
'left-part'   Name.Variable
')'           Punctuation
' '           Text
'30'          Literal.Number.Integer
')'           Punctuation
'\n\t\t\t\t      ' Text
'('           Punctuation
'< '          Name.Builtin
'('           Punctuation
'string-length ' Name.Builtin
'help'        Name.Variable
')'           Punctuation
' '           Text
'40'          Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t ' Text
'('           Punctuation
'make-string ' Name.Builtin
'('           Punctuation
'- '          Name.Builtin
'30'          Literal.Number.Integer
' '           Text
'('           Punctuation
'string-length ' Name.Builtin
'left-part'   Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'#\\ '        Literal.String.Char
')'           Punctuation
'\n\t\t\t\t ' Text
'"\\n\\t"'    Literal.String
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'display '    Name.Builtin
'left-part'   Name.Variable
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'display '    Name.Builtin
'middle-part' Name.Variable
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'display '    Name.Builtin
'help'        Name.Variable
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'newline'     Name.Function
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n   '       Text
'kw-desc'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\n\n'    Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'transform-usage-lambda' Name.Function
' '           Text
'cases'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'raw-usage'   Name.Function
' '           Text
'('           Punctuation
'delq!'       Name.Function
' '           Text
"'else"       Literal.String.Symbol
' '           Text
'('           Punctuation
'map '        Name.Builtin
'car'         Name.Variable
' '           Text
'cases'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'usage-sans-specials' Name.Function
' '           Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'x'           Name.Function
')'           Punctuation
'\n\t\t\t\t    ' Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'list? '      Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'x'           Name.Variable
')'           Punctuation
'\n\t\t\t\t\t' Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'symbol? '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'#t'          Name.Constant
')'           Punctuation
'\n\t\t\t\t\t' Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'boolean? '   Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'#t'          Name.Constant
')'           Punctuation
'\n\t\t\t\t\t' Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t  ' Text
'raw-usage'   Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'usage-desc'  Name.Function
' '           Text
'('           Punctuation
'delq!'       Name.Function
' '           Text
'#t'          Name.Constant
' '           Text
'usage-sans-specials' Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'kw-desc'     Name.Function
' '           Text
'('           Punctuation
'map '        Name.Builtin
'car'         Name.Variable
' '           Text
'usage-desc'  Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'kw-opts'     Name.Function
' '           Text
'('           Punctuation
'apply '      Name.Builtin
'append'      Name.Variable
' '           Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'x'           Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'string? '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'kw-desc'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'kw-args'     Name.Function
' '           Text
'('           Punctuation
'apply '      Name.Builtin
'append'      Name.Variable
' '           Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'x'           Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'string? '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'x'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
' '           Text
'kw-desc'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'transmogrified-cases' Name.Function
' '           Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'case'        Name.Function
')'           Punctuation
'\n\t\t\t\t      ' Text
'('           Punctuation
'cons '       Name.Builtin
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'opts'        Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'case'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t      ' Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'or '         Keyword
'('           Punctuation
'boolean? '   Name.Builtin
'opts'        Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'eq? '        Name.Builtin
"'else"       Literal.String.Symbol
' '           Text
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t\t  ' Text
'opts'        Name.Variable
'\n\t\t\t\t\t\t  ' Text
'('           Punctuation
'cond'        Name.Function
'\n\t\t\t\t\t\t   ' Text
'('           Punctuation
'('           Punctuation
'symbol? '    Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
'  '          Text
'opts'        Name.Variable
')'           Punctuation
'\n\t\t\t\t\t\t   ' Text
'('           Punctuation
'('           Punctuation
'boolean? '   Name.Builtin
'('           Punctuation
'car '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'opts'        Name.Variable
')'           Punctuation
'\n\t\t\t\t\t\t   ' Text
'('           Punctuation
'('           Punctuation
'string? '    Name.Builtin
'('           Punctuation
'caar '       Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdar '       Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t\t   ' Text
'('           Punctuation
'else '       Keyword
'('           Punctuation
'car '        Name.Builtin
'opts'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t    ' Text
'('           Punctuation
'cdr '        Name.Builtin
'case'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t    ' Text
'cases'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'`'           Operator
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'%display-usage' Name.Function
' '           Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'display-usage-report' Name.Function
' '           Text
"',usage-desc" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'%argv'       Name.Function
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'let '        Keyword
'%next-arg'   Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'%argv'       Name.Function
' '           Text
'%argv'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'get-option'  Name.Function
' '           Text
'%argv'       Name.Variable
'\n\t\t       ' Text
"',kw-opts"   Literal.String.Symbol
'\n\t\t       ' Text
"',kw-args"   Literal.String.Symbol
'\n\t\t       ' Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'%opt'        Name.Function
' '           Text
'%arg'        Name.Variable
' '           Text
'%new-argv'   Name.Variable
')'           Punctuation
'\n\t\t\t '   Text
'('           Punctuation
'case '       Keyword
'%opt'        Name.Variable
'\n\t\t\t   ' Text
',@'          Operator
' '           Text
'transmogrified-cases' Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n\x0c\n\n' Text

';;; {Low Level Modules}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; These are the low level data structures for modules.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; !!! warning: The interface to lazy binder procedures is going' Comment.Single
'\n'          Text

';;; to be changed in an incompatible way to permit all the basic' Comment.Single
'\n'          Text

';;; module ops to be virtualized.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; (make-module size use-list lazy-binding-proc) => module' Comment.Single
'\n'          Text

';;; module-{obarray,uses,binder}[|-set!]' Comment.Single
'\n'          Text

';;; (module? obj) => [#t|#f]' Comment.Single
'\n'          Text

';;; (module-locally-bound? module symbol) => [#t|#f]' Comment.Single
'\n'          Text

';;; (module-bound? module symbol) => [#t|#f]' Comment.Single
'\n'          Text

';;; (module-symbol-locally-interned? module symbol) => [#t|#f]' Comment.Single
'\n'          Text

';;; (module-symbol-interned? module symbol) => [#t|#f]' Comment.Single
'\n'          Text

';;; (module-local-variable module symbol) => [#<variable ...> | #f]' Comment.Single
'\n'          Text

';;; (module-variable module symbol) => [#<variable ...> | #f]' Comment.Single
'\n'          Text

';;; (module-symbol-binding module symbol opt-value)' Comment.Single
'\n'          Text

';;;\t\t=> [ <obj> | opt-value | an error occurs ]' Comment.Single
'\n'          Text

';;; (module-make-local-var! module symbol) => #<variable...>' Comment.Single
'\n'          Text

';;; (module-add! module symbol var) => unspecified' Comment.Single
'\n'          Text

';;; (module-remove! module symbol) =>  unspecified' Comment.Single
'\n'          Text

';;; (module-for-each proc module) => unspecified' Comment.Single
'\n'          Text

';;; (make-scm-module) => module ; a lazy copy of the symhash module' Comment.Single
'\n'          Text

';;; (set-current-module module) => unspecified' Comment.Single
'\n'          Text

';;; (current-module) => #<module...>' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n\x0c\n'  Text

';;; {Printing Modules}' Comment.Single
'\n'          Text

';; This is how modules are printed.  You can re-define it.' Comment.Single
'\n'          Text

';; (Redefining is actually more complicated than simply redefining' Comment.Single
'\n'          Text

';; %print-module because that would only change the binding and not' Comment.Single
'\n'          Text

';; the value stored in the vtable that determines how record are' Comment.Single
'\n'          Text

';; printed. Sigh.)' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'%print-module' Name.Function
' '           Text
'mod'         Name.Variable
' '           Text
'port'        Name.Variable
')'           Punctuation
'  '          Text
'; unused args: depth length style table)' Comment.Single
'\n  '        Text
'('           Punctuation
'display '    Name.Builtin
'"#<"'        Literal.String
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'display '    Name.Builtin
'('           Punctuation
'or '         Keyword
'('           Punctuation
'module-kind' Name.Function
' '           Text
'mod'         Name.Variable
')'           Punctuation
' '           Text
'"module"'    Literal.String
')'           Punctuation
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'name'        Name.Function
' '           Text
'('           Punctuation
'module-name' Name.Function
' '           Text
'mod'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'name'        Name.Variable
'\n\t'        Text
'('           Punctuation
'begin'       Name.Function
'\n\t  '      Text
'('           Punctuation
'display '    Name.Builtin
'" "'         Literal.String
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'display '    Name.Builtin
'name'        Name.Variable
' '           Text
'port'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'display '    Name.Builtin
'" "'         Literal.String
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'display '    Name.Builtin
'('           Punctuation
'number->string ' Name.Builtin
'('           Punctuation
'object-address' Name.Function
' '           Text
'mod'         Name.Variable
')'           Punctuation
' '           Text
'16'          Literal.Number.Integer
')'           Punctuation
' '           Text
'port'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'display '    Name.Builtin
'">"'         Literal.String
' '           Text
'port'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-type' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; A module is characterized by an obarray in which local symbols' Comment.Single
'\n'          Text

';; are interned, a list of modules, "uses", from which non-local' Comment.Single
'\n'          Text

';; bindings can be inherited, and an optional lazy-binder which' Comment.Single
'\n'          Text

';; is a (CLOSURE module symbol) which, as a last resort, can provide' Comment.Single
'\n'          Text

';; bindings that would otherwise not be found locally in the module.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; NOTE: If you change here, you also need to change libguile/modules.h.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-type' Name.Variable
'\n  '        Text
'('           Punctuation
'make-record-type' Name.Function
' '           Text
"'module"     Literal.String.Symbol
'\n\t\t    '  Text
"'"           Operator
'('           Punctuation
'obarray'     Name.Variable
' '           Text
'uses'        Name.Variable
' '           Text
'binder'      Name.Variable
' '           Text
'eval-closure' Name.Variable
' '           Text
'transformer' Name.Variable
' '           Text
'name'        Name.Variable
' '           Text
'kind'        Name.Variable
'\n\t\t\t      ' Text
'observers'   Name.Variable
' '           Text
'weak-observers' Name.Variable
' '           Text
'observer-id' Name.Variable
')'           Punctuation
'\n\t\t    '  Text
'%print-module' Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; make-module &opt size uses binder' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Create a new module, perhaps with a particular size of obarray,' Comment.Single
'\n'          Text

';; initial uses list, or binding procedure.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'make-module' Name.Variable
'\n    '      Text
'('           Punctuation
'lambda '     Keyword
'args'        Name.Variable
'\n\n      '  Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'parse-arg'   Name.Function
' '           Text
'index'       Name.Variable
' '           Text
'default'     Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'> '          Name.Builtin
'('           Punctuation
'length '     Name.Builtin
'args'        Name.Variable
')'           Punctuation
' '           Text
'index'       Name.Variable
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'list-ref '   Name.Builtin
'args'        Name.Variable
' '           Text
'index'       Name.Variable
')'           Punctuation
'\n\t    '    Text
'default'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n      '  Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'> '          Name.Builtin
'('           Punctuation
'length '     Name.Builtin
'args'        Name.Variable
')'           Punctuation
' '           Text
'3'           Literal.Number.Integer
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"Too many args to make-module."' Literal.String
' '           Text
'args'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n      '  Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'size'        Name.Function
' '           Text
'('           Punctuation
'parse-arg'   Name.Function
' '           Text
'0'           Literal.Number.Integer
' '           Text
'1021'        Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'uses'        Name.Function
' '           Text
'('           Punctuation
'parse-arg'   Name.Function
' '           Text
'1'           Literal.Number.Integer
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'binder'      Name.Function
' '           Text
'('           Punctuation
'parse-arg'   Name.Function
' '           Text
'2'           Literal.Number.Integer
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\t'      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'integer? '   Name.Builtin
'size'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"Illegal size to make-module."' Literal.String
' '           Text
'size'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'and '        Keyword
'('           Punctuation
'list? '      Name.Builtin
'uses'        Name.Variable
')'           Punctuation
'\n\t\t      ' Text
'('           Punctuation
'and-map'     Name.Function
' '           Text
'module?'     Name.Variable
' '           Text
'uses'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"Incorrect use list."' Literal.String
' '           Text
'uses'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'binder'      Name.Variable
' '           Text
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'procedure? ' Name.Builtin
'binder'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'error'       Name.Function
'\n\t     '   Text
'"Lazy-binder expected to be a procedure or #f."' Literal.String
' '           Text
'binder'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\t'      Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'module'      Name.Function
' '           Text
'('           Punctuation
'module-constructor' Name.Function
' '           Text
'('           Punctuation
'make-vector ' Name.Builtin
'size'        Name.Variable
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t\t\t\t  ' Text
'uses'        Name.Variable
' '           Text
'binder'      Name.Variable
' '           Text
'#f'          Name.Constant
' '           Text
'#f'          Name.Constant
' '           Text
'#f'          Name.Constant
' '           Text
'#f'          Name.Constant
'\n\t\t\t\t\t  ' Text
"'"           Operator
'('           Punctuation
')'           Punctuation
'\n\t\t\t\t\t  ' Text
'('           Punctuation
'make-weak-value-hash-table' Name.Function
' '           Text
'31'          Literal.Number.Integer
')'           Punctuation
'\n\t\t\t\t\t  ' Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\t  '    Text
";; We can't pass this as an argument to module-constructor," Comment.Single
'\n\t  '      Text
';; because we need it to close over a pointer to the module' Comment.Single
'\n\t  '      Text
';; itself.'  Comment.Single
'\n\t  '      Text
'('           Punctuation
'set-module-eval-closure!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'('           Punctuation
'standard-eval-closure' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\t  '    Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'module-constructor' Name.Variable
' '           Text
'('           Punctuation
'record-constructor' Name.Function
' '           Text
'module-type' Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-obarray' Name.Variable
'  '          Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'obarray"    Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-obarray!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'obarray"    Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-uses' Name.Variable
'  '          Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'uses"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-uses!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'uses"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-binder' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'binder"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-binder!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'binder"     Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; NOTE: This binding is used in libguile/modules.c.' Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-eval-closure' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'eval-closure" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'module-transformer' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'transformer" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-transformer!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'transformer" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-name' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'name"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-name!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'name"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-kind' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'kind"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-kind!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'kind"       Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-observers' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'observers"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-observers!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'observers"  Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-weak-observers' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'weak-observers" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module-observer-id' Name.Variable
' '           Text
'('           Punctuation
'record-accessor' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'observer-id" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'set-module-observer-id!' Name.Variable
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'observer-id" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'module?'     Name.Variable
' '           Text
'('           Punctuation
'record-predicate' Name.Function
' '           Text
'module-type' Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'set-module-eval-closure!' Name.Variable
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'setter'      Name.Function
' '           Text
'('           Punctuation
'record-modifier' Name.Function
' '           Text
'module-type' Name.Variable
' '           Text
"'eval-closure" Literal.String.Symbol
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'module'      Name.Function
' '           Text
'closure'     Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'setter'      Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'closure'     Name.Variable
')'           Punctuation
'\n      '    Text
';; Make it possible to lookup the module from the environment.' Comment.Single
'\n      '    Text
';; This implementation is correct since an eval closure can belong' Comment.Single
'\n      '    Text
';; to maximally one module.' Comment.Single
'\n      '    Text
'('           Punctuation
'set-procedure-property!' Name.Function
' '           Text
'closure'     Name.Variable
' '           Text
"'module"     Literal.String.Symbol
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'begin-deprecated' Name.Function
'\n '         Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'eval-in-module' Name.Function
' '           Text
'exp'         Name.Variable
' '           Text
'mod'         Name.Variable
')'           Punctuation
'\n   '       Text
'('           Punctuation
'issue-deprecation-warning' Name.Function
'\n    '      Text
'"`eval-in-module\' is deprecated.  Use `eval\' instead."' Literal.String
')'           Punctuation
'\n   '       Text
'('           Punctuation
'eval '       Name.Builtin
'exp'         Name.Variable
' '           Text
'mod'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Observer protocol}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-observe' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'proc'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'set-module-observers!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'('           Punctuation
'cons '       Name.Builtin
'proc'        Name.Variable
' '           Text
'('           Punctuation
'module-observers' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'cons '       Name.Builtin
'module'      Name.Variable
' '           Text
'proc'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-observe-weak' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'proc'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'id'          Name.Function
' '           Text
'('           Punctuation
'module-observer-id' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'hash-set!'   Name.Function
' '           Text
'('           Punctuation
'module-weak-observers' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
' '           Text
'id'          Name.Variable
' '           Text
'proc'        Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'set-module-observer-id!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'id'          Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'cons '       Name.Builtin
'module'      Name.Variable
' '           Text
'id'          Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-unobserve' Name.Function
' '           Text
'token'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'module'      Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'token'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'id'          Name.Function
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'token'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'integer? '   Name.Builtin
'id'          Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'hash-remove!' Name.Function
' '           Text
'('           Punctuation
'module-weak-observers' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
' '           Text
'id'          Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'set-module-observers!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'('           Punctuation
'delq1!'      Name.Function
' '           Text
'id'          Name.Variable
' '           Text
'('           Punctuation
'module-observers' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'*unspecified*' Name.Variable
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-modified' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'for-each '   Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'proc'        Name.Function
')'           Punctuation
' '           Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'module-observers' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'hash-fold'   Name.Function
' '           Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'id'          Name.Function
' '           Text
'proc'        Name.Variable
' '           Text
'res'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'#f'          Name.Constant
' '           Text
'('           Punctuation
'module-weak-observers' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Module Searching in General}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; We sometimes want to look for properties of a symbol' Comment.Single
'\n'          Text

';;; just within the obarray of one module.  If the property' Comment.Single
'\n'          Text

";;; holds, then it is said to hold ``locally'' as in, ``The symbol" Comment.Single
'\n'          Text

";;; DISPLAY is locally rebound in the module `safe-guile'.''" Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; Other times, we want to test for a symbol property in the obarray' Comment.Single
'\n'          Text

';;; of M and, if it is not found there, try each of the modules in the' Comment.Single
'\n'          Text

';;; uses list of M.  This is the normal way of testing for some' Comment.Single
'\n'          Text

';;; property, so we state these properties without qualification as' Comment.Single
'\n'          Text

";;; in: ``The symbol 'fnord is interned in module M because it is" Comment.Single
'\n'          Text

';;; interned locally in module M2 which is a member of the uses list' Comment.Single
'\n'          Text

";;; of M.''" Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; module-search fn m' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; return the first non-#f result of FN applied to M and then to' Comment.Single
'\n'          Text

';; the modules in the uses of m, and so on recursively.  If all applications' Comment.Single
'\n'          Text

';; return #f, then so does this function.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-search' Name.Function
' '           Text
'fn'          Name.Variable
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'define '     Keyword
'('           Punctuation
'loop'        Name.Function
' '           Text
'pos'         Name.Variable
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'pair? '      Name.Builtin
'pos'         Name.Variable
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'module-search' Name.Function
' '           Text
'fn'          Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'pos'         Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'pos'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'fn'          Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'module-uses' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n'      Text

';;; {Is a symbol bound in a module?}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; Symbol S in Module M is bound if S is interned in M and if the binding' Comment.Single
'\n'          Text

';;; of S in M has been set to some well-defined value.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; module-locally-bound? module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Is a symbol bound (interned and defined) locally in a given module?' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-locally-bound?' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'var'         Name.Function
' '           Text
'('           Punctuation
'module-local-variable' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'var'         Name.Variable
'\n\t '       Text
'('           Punctuation
'variable-bound?' Name.Function
' '           Text
'var'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-bound? module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Is a symbol bound (interned and defined) anywhere in a given module' Comment.Single
'\n'          Text

';; or its uses?' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-bound?' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-search' Name.Function
' '           Text
'module-locally-bound?' Name.Variable
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';;; {Is a symbol interned in a module?}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; Symbol S in Module M is interned if S occurs in' Comment.Single
'\n'          Text

';;; of S in M has been set to some well-defined value.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; It is possible to intern a symbol in a module without providing' Comment.Single
'\n'          Text

';;; an initial binding for the corresponding variable.  This is done' Comment.Single
'\n'          Text

';;; with:'   Comment.Single
'\n'          Text

';;;       (module-add! module symbol (make-undefined-variable))' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; In that case, the symbol is interned in the module, but not' Comment.Single
'\n'          Text

';;; bound there.  The unbound symbol shadows any binding for that' Comment.Single
'\n'          Text

';;; symbol that might otherwise be inherited from a member of the uses list.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-obarray-get-handle' Name.Function
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'('           Punctuation
'if '         Keyword
'('           Punctuation
'symbol? '    Name.Builtin
'key'         Name.Variable
')'           Punctuation
' '           Text
'hashq-get-handle' Name.Variable
' '           Text
'hash-get-handle' Name.Variable
')'           Punctuation
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-obarray-ref' Name.Function
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'('           Punctuation
'if '         Keyword
'('           Punctuation
'symbol? '    Name.Builtin
'key'         Name.Variable
')'           Punctuation
' '           Text
'hashq-ref'   Name.Variable
' '           Text
'hash-ref'    Name.Variable
')'           Punctuation
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-obarray-set!' Name.Function
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'('           Punctuation
'if '         Keyword
'('           Punctuation
'symbol? '    Name.Builtin
'key'         Name.Variable
')'           Punctuation
' '           Text
'hashq-set!'  Name.Variable
' '           Text
'hash-set!'   Name.Variable
')'           Punctuation
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-obarray-remove!' Name.Function
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'('           Punctuation
'if '         Keyword
'('           Punctuation
'symbol? '    Name.Builtin
'key'         Name.Variable
')'           Punctuation
' '           Text
'hashq-remove!' Name.Variable
' '           Text
'hash-remove!' Name.Variable
')'           Punctuation
' '           Text
'ob'          Name.Variable
' '           Text
'key'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-symbol-locally-interned? module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; is a symbol interned (not neccessarily defined) locally in a given module' Comment.Single
'\n'          Text

';; or its uses?  Interned symbols shadow inherited bindings even if' Comment.Single
'\n'          Text

';; they are not themselves bound to a defined value.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-symbol-locally-interned?' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'module-obarray-get-handle' Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-symbol-interned? module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; is a symbol interned (not neccessarily defined) anywhere in a given module' Comment.Single
'\n'          Text

';; or its uses?  Interned symbols shadow inherited bindings even if' Comment.Single
'\n'          Text

';; they are not themselves bound to a defined value.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-symbol-interned?' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-search' Name.Function
' '           Text
'module-symbol-locally-interned?' Name.Variable
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\n'      Text

';;; {Mapping modules x symbols --> variables}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; module-local-variable module symbol' Comment.Single
'\n'          Text

';; return the local variable associated with a MODULE and SYMBOL.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';;; This function is very important. It is the only function that can' Comment.Single
'\n'          Text

';;; return a variable from a module other than the mutators that store' Comment.Single
'\n'          Text

';;; new variables in modules.  Therefore, this function is the location' Comment.Single
'\n'          Text

';;; of the "lazy binder" hack.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; If symbol is defined in MODULE, and if the definition binds symbol' Comment.Single
'\n'          Text

';;; to a variable, return that variable object.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; If the symbols is not found at first, but the module has a lazy binder,' Comment.Single
'\n'          Text

';;; then try the binder.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; If the symbol is not found at all, return #f.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-local-variable' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n'          Text

';  (caddr'   Comment.Single
'\n'          Text

';   (list m v' Comment.Single
'\n\t '       Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'b'           Name.Function
' '           Text
'('           Punctuation
'module-obarray-ref' Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'and '        Keyword
'('           Punctuation
'variable?'   Name.Function
' '           Text
'b'           Name.Variable
')'           Punctuation
' '           Text
'b'           Name.Variable
')'           Punctuation
'\n\t       ' Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'module-binder' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'('           Punctuation
'module-binder' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n'          Text

';))'         Comment.Single
'\n\n'        Text

';; module-variable module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; like module-local-variable, except search the uses in the' Comment.Single
'\n'          Text

';; case V is not found in M.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; NOTE: This function is superseded with C code (see modules.c)' Comment.Single
'\n'          Text

';;;      when using the standard eval closure.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-variable' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-search' Name.Function
' '           Text
'module-local-variable' Name.Variable
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\n'      Text

';;; {Mapping modules x symbols --> bindings}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; These are similar to the mapping to variables, except that the' Comment.Single
'\n'          Text

';;; variable is dereferenced.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; module-symbol-binding module symbol opt-value' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; return the binding of a variable specified by name within' Comment.Single
'\n'          Text

';; a given module, signalling an error if the variable is unbound.' Comment.Single
'\n'          Text

';; If the OPT-VALUE is passed, then instead of signalling an error,' Comment.Single
'\n'          Text

';; return OPT-VALUE.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-symbol-local-binding' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
' '           Text
'.'           Operator
' '           Text
'opt-val'     Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'var'         Name.Function
' '           Text
'('           Punctuation
'module-local-variable' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'var'         Name.Variable
'\n\t'        Text
'('           Punctuation
'variable-ref' Name.Function
' '           Text
'var'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'null? '      Name.Builtin
'opt-val'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'car '        Name.Builtin
'opt-val'     Name.Variable
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"Locally unbound variable."' Literal.String
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-symbol-binding module symbol opt-value' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; return the binding of a variable specified by name within' Comment.Single
'\n'          Text

';; a given module, signalling an error if the variable is unbound.' Comment.Single
'\n'          Text

';; If the OPT-VALUE is passed, then instead of signalling an error,' Comment.Single
'\n'          Text

';; return OPT-VALUE.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-symbol-binding' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
' '           Text
'.'           Operator
' '           Text
'opt-val'     Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'var'         Name.Function
' '           Text
'('           Punctuation
'module-variable' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'var'         Name.Variable
'\n\t'        Text
'('           Punctuation
'variable-ref' Name.Function
' '           Text
'var'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'null? '      Name.Builtin
'opt-val'     Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'car '        Name.Builtin
'opt-val'     Name.Variable
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"Unbound variable."' Literal.String
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n\x0c\n' Text

';;; {Adding Variables to Modules}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n\n'      Text

';; module-make-local-var! module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; ensure a variable for V in the local namespace of M.' Comment.Single
'\n'          Text

';; If no variable was already there, then create a new and uninitialzied' Comment.Single
'\n'          Text

';; variable.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-make-local-var!' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'b'           Name.Function
' '           Text
'('           Punctuation
'module-obarray-ref' Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'variable?'   Name.Function
' '           Text
'b'           Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'begin'       Name.Function
'\n\t       ' Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
'\n\t       ' Text
'b'           Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'module-binder' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
'\n\t   '     Text
'('           Punctuation
'('           Punctuation
'module-binder' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
' '           Text
'#t'          Name.Constant
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'begin'       Name.Function
'\n\t'        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'answer'      Name.Function
' '           Text
'('           Punctuation
'make-undefined-variable' Name.Function
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'variable-set-name-hint!' Name.Function
' '           Text
'answer'      Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'module-obarray-set!' Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
' '           Text
'answer'      Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
'\n\t  '      Text
'answer'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-ensure-local-variable! module symbol' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Ensure that there is a local variable in MODULE for SYMBOL.  If' Comment.Single
'\n'          Text

';; there is no binding for SYMBOL, create a new uninitialized' Comment.Single
'\n'          Text

';; variable.  Return the local variable.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-ensure-local-variable!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'symbol'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'or '         Keyword
'('           Punctuation
'module-local-variable' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'symbol'      Name.Variable
')'           Punctuation
'\n      '    Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'var'         Name.Function
' '           Text
'('           Punctuation
'make-undefined-variable' Name.Function
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'variable-set-name-hint!' Name.Function
' '           Text
'var'         Name.Variable
' '           Text
'symbol'      Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'module-add!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'symbol'      Name.Variable
' '           Text
'var'         Name.Variable
')'           Punctuation
'\n\t'        Text
'var'         Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-add! module symbol var' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; ensure a particular variable for V in the local namespace of M.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-add!' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
' '           Text
'var'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'variable?'   Name.Function
' '           Text
'var'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"Bad variable to module-add!"' Literal.String
' '           Text
'var'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-obarray-set!' Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
' '           Text
'var'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; module-remove!' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; make sure that a symbol is undefined in the local namespace of M.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-remove!' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-obarray-remove!' Name.Function
'  '          Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
'v'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-clear!' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'vector-fill! ' Name.Builtin
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; MODULE-FOR-EACH -- exported' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Call PROC on each symbol in MODULE, with arguments of (SYMBOL VARIABLE).' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-for-each' Name.Function
' '           Text
'proc'        Name.Variable
' '           Text
'module'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'obarray'     Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'do '         Keyword
'('           Punctuation
'('           Punctuation
'index'       Name.Function
' '           Text
'0'           Literal.Number.Integer
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'index'       Name.Variable
' '           Text
'1'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'end'         Name.Function
' '           Text
'('           Punctuation
'vector-length ' Name.Builtin
'obarray'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'('           Punctuation
'= '          Name.Builtin
'index'       Name.Variable
' '           Text
'end'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'for-each'    Name.Function
'\n       '   Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'bucket'      Name.Function
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'bucket'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'bucket'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obarray'     Name.Variable
' '           Text
'index'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n'      Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-map'  Name.Function
' '           Text
'proc'        Name.Variable
' '           Text
'module'      Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let* '       Keyword
'('           Punctuation
'('           Punctuation
'obarray'     Name.Function
' '           Text
'('           Punctuation
'module-obarray' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t '       Text
'('           Punctuation
'end'         Name.Function
' '           Text
'('           Punctuation
'vector-length ' Name.Builtin
'obarray'     Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n    '    Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'i'           Name.Function
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
'\n\t       ' Text
'('           Punctuation
'answer'      Name.Function
' '           Text
"'"           Operator
'('           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n      '    Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'= '          Name.Builtin
'i'           Name.Variable
' '           Text
'end'         Name.Variable
')'           Punctuation
'\n\t  '      Text
'answer'      Name.Variable
'\n\t  '      Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'+ '          Name.Builtin
'1'           Literal.Number.Integer
' '           Text
'i'           Name.Variable
')'           Punctuation
'\n\t\t'      Text
'('           Punctuation
'append!'     Name.Function
'\n\t\t '     Text
'('           Punctuation
'map '        Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
'bucket'      Name.Function
')'           Punctuation
'\n\t\t\t'    Text
'('           Punctuation
'proc'        Name.Function
' '           Text
'('           Punctuation
'car '        Name.Builtin
'bucket'      Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'bucket'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t      ' Text
'('           Punctuation
'vector-ref ' Name.Builtin
'obarray'     Name.Variable
' '           Text
'i'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t\t '     Text
'answer'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\x0c\n\n'  Text

';;; {Low Level Bootstrapping}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

';; make-root-module' Comment.Single
'\n\n'        Text

';; A root module uses the pre-modules-obarray as its obarray.  This' Comment.Single
'\n'          Text

';; special obarray accumulates all bindings that have been established' Comment.Single
'\n'          Text

';; before the module system is fully booted.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; (The obarray continues to be used by code that has been closed over' Comment.Single
'\n'          Text

';;  before the module system has been booted.)' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'make-root-module' Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'm'           Name.Function
' '           Text
'('           Punctuation
'make-module' Name.Function
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'set-module-obarray!' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'('           Punctuation
'%get-pre-modules-obarray' Name.Function
')'           Punctuation
')'           Punctuation
'\n    '      Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; make-scm-module' Comment.Single
'\n\n'        Text

';; The root interface is a module that uses the same obarray as the' Comment.Single
'\n'          Text

';; root module.  It does not allow new definitions, tho.' Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'make-scm-module' Name.Function
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'm'           Name.Function
' '           Text
'('           Punctuation
'make-module' Name.Function
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'set-module-obarray!' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'('           Punctuation
'%get-pre-modules-obarray' Name.Function
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'set-module-eval-closure!' Name.Function
' '           Text
'm'           Name.Variable
' '           Text
'('           Punctuation
'standard-interface-eval-closure' Name.Function
' '           Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'm'           Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\n\x0c\n' Text

';;; {Module-based Loading}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'save-module-excursion' Name.Function
' '           Text
'thunk'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'inner-module' Name.Function
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'outer-module' Name.Function
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'dynamic-wind ' Name.Builtin
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'set! '       Keyword
'outer-module' Name.Variable
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'set-current-module' Name.Function
' '           Text
'inner-module' Name.Variable
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'set! '       Keyword
'inner-module' Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
'\n\t\t  '    Text
'thunk'       Name.Variable
'\n\t\t  '    Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'set! '       Keyword
'inner-module' Name.Variable
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'set-current-module' Name.Function
' '           Text
'outer-module' Name.Variable
')'           Punctuation
'\n\t\t    '  Text
'('           Punctuation
'set! '       Keyword
'outer-module' Name.Variable
' '           Text
'#f'          Name.Constant
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'basic-load'  Name.Variable
' '           Text
'load'        Name.Variable
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'load-module' Name.Function
' '           Text
'filename'    Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'save-module-excursion' Name.Function
'\n   '       Text
'('           Punctuation
'lambda '     Keyword
'('           Punctuation
')'           Punctuation
'\n     '     Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'oldname'     Name.Function
' '           Text
'('           Punctuation
'and '        Keyword
'('           Punctuation
'current-load-port' Name.Function
')'           Punctuation
'\n\t\t\t '   Text
'('           Punctuation
'port-filename' Name.Function
' '           Text
'('           Punctuation
'current-load-port' Name.Function
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n       '   Text
'('           Punctuation
'basic-load'  Name.Function
' '           Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'oldname'     Name.Variable
'\n\t\t\t    ' Text
'('           Punctuation
'> '          Name.Builtin
'('           Punctuation
'string-length ' Name.Builtin
'filename'    Name.Variable
')'           Punctuation
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
'\n\t\t\t    ' Text
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'char=? '     Name.Builtin
'('           Punctuation
'string-ref ' Name.Builtin
'filename'    Name.Variable
' '           Text
'0'           Literal.Number.Integer
')'           Punctuation
' '           Text
'#\\/'        Literal.String.Char
')'           Punctuation
')'           Punctuation
'\n\t\t\t    ' Text
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'string=? '   Name.Builtin
'('           Punctuation
'dirname'     Name.Function
' '           Text
'oldname'     Name.Variable
')'           Punctuation
' '           Text
'"."'         Literal.String
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t\t       ' Text
'('           Punctuation
'string-append ' Name.Builtin
'('           Punctuation
'dirname'     Name.Function
' '           Text
'oldname'     Name.Variable
')'           Punctuation
' '           Text
'"/"'         Literal.String
' '           Text
'filename'    Name.Variable
')'           Punctuation
'\n\t\t       ' Text
'filename'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n\n\x0c\n' Text

';;; {MODULE-REF -- exported}' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Returns the value of a variable called NAME in MODULE or any of its' Comment.Single
'\n'          Text

';; used modules.  If there is no such variable, then if the optional third' Comment.Single
'\n'          Text

';; argument DEFAULT is present, it is returned; otherwise an error is signaled.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-ref'  Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
' '           Text
'.'           Operator
' '           Text
'rest'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'variable'    Name.Function
' '           Text
'('           Punctuation
'module-variable' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'and '        Keyword
'variable'    Name.Variable
' '           Text
'('           Punctuation
'variable-bound?' Name.Function
' '           Text
'variable'    Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'variable-ref' Name.Function
' '           Text
'variable'    Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'null? '      Name.Builtin
'rest'        Name.Variable
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"No variable named"' Literal.String
' '           Text
'name'        Name.Variable
' '           Text
"'in"         Literal.String.Symbol
' '           Text
'module'      Name.Variable
')'           Punctuation
'\n\t    '    Text
'('           Punctuation
'car '        Name.Builtin
'rest'        Name.Variable
')'           Punctuation
'\t\t\t'      Text
'; default value' Comment.Single
'\n\t    '    Text
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; MODULE-SET! -- exported' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Sets the variable called NAME in MODULE (or in a module that MODULE uses)' Comment.Single
'\n'          Text

';; to VALUE; if there is no such variable, an error is signaled.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-set!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
' '           Text
'value'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'variable'    Name.Function
' '           Text
'('           Punctuation
'module-variable' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'variable'    Name.Variable
'\n\t'        Text
'('           Punctuation
'variable-set!' Name.Function
' '           Text
'variable'    Name.Variable
' '           Text
'value'       Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'error'       Name.Function
' '           Text
'"No variable named"' Literal.String
' '           Text
'name'        Name.Variable
' '           Text
"'in"         Literal.String.Symbol
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; MODULE-DEFINE! -- exported' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Sets the variable called NAME in MODULE to VALUE; if there is no such' Comment.Single
'\n'          Text

';; variable, it is added first.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-define!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
' '           Text
'value'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'variable'    Name.Function
' '           Text
'('           Punctuation
'module-local-variable' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'variable'    Name.Variable
'\n\t'        Text
'('           Punctuation
'begin'       Name.Function
'\n\t  '      Text
'('           Punctuation
'variable-set!' Name.Function
' '           Text
'variable'    Name.Variable
' '           Text
'value'       Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'variable'    Name.Function
' '           Text
'('           Punctuation
'make-variable' Name.Function
' '           Text
'value'       Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'variable-set-name-hint!' Name.Function
' '           Text
'variable'    Name.Variable
' '           Text
'name'        Name.Variable
')'           Punctuation
'\n\t  '      Text
'('           Punctuation
'module-add!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
' '           Text
'variable'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; MODULE-DEFINED? -- exported' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Return #t iff NAME is defined in MODULE (or in a module that MODULE' Comment.Single
'\n'          Text

';; uses)'    Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-defined?' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'('           Punctuation
'('           Punctuation
'variable'    Name.Function
' '           Text
'('           Punctuation
'module-variable' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'name'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'and '        Keyword
'variable'    Name.Variable
' '           Text
'('           Punctuation
'variable-bound?' Name.Function
' '           Text
'variable'    Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

';; MODULE-USE! module interface' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

';; Add INTERFACE to the list of interfaces used by MODULE.' Comment.Single
'\n'          Text

';;'          Comment.Single
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'module-use!' Name.Function
' '           Text
'module'      Name.Variable
' '           Text
'interface'   Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'set-module-uses!' Name.Function
' '           Text
'module'      Name.Variable
'\n\t\t    '  Text
'('           Punctuation
'cons '       Name.Builtin
'interface'   Name.Variable
' '           Text
'('           Punctuation
'delq!'       Name.Function
' '           Text
'interface'   Name.Variable
' '           Text
'('           Punctuation
'module-uses' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n  '        Text
'('           Punctuation
'module-modified' Name.Function
' '           Text
'module'      Name.Variable
')'           Punctuation
')'           Punctuation
'\n\n\x0c\n'  Text

';;; {Recursive Namespaces}' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; A hierarchical namespace emerges if we consider some module to be' Comment.Single
'\n'          Text

';;; root, and variables bound to modules as nested namespaces.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; The routines in this file manage variable names in hierarchical namespace.' Comment.Single
'\n'          Text

';;; Each variable name is a list of elements, looked up in successively nested' Comment.Single
'\n'          Text

';;; modules.' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

";;;\t\t(nested-ref some-root-module '(foo bar baz))" Comment.Single
'\n'          Text

';;;\t\t=> <value of a variable named baz in the module bound to bar in' Comment.Single
'\n'          Text

';;;\t\t    the module bound to foo in some-root-module>' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; There are:' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;\t;; a-root is a module' Comment.Single
'\n'          Text

';;;\t;; name is a list of symbols' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;\tnested-ref a-root name' Comment.Single
'\n'          Text

';;;\tnested-set! a-root name val' Comment.Single
'\n'          Text

';;;\tnested-define! a-root name val' Comment.Single
'\n'          Text

';;;\tnested-remove! a-root name' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;; (current-module) is a natural choice for a-root so for convenience there are' Comment.Single
'\n'          Text

';;; also:'   Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n'          Text

';;;\tlocal-ref name\t\t==\tnested-ref (current-module) name' Comment.Single
'\n'          Text

';;;\tlocal-set! name val\t==\tnested-set! (current-module) name val' Comment.Single
'\n'          Text

';;;\tlocal-define! name val\t==\tnested-define! (current-module) name val' Comment.Single
'\n'          Text

';;;\tlocal-remove! name\t==\tnested-remove! (current-module) name' Comment.Single
'\n'          Text

';;;'         Comment.Single
'\n\n\n'      Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'nested-ref'  Name.Function
' '           Text
'root'        Name.Variable
' '           Text
'names'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'cur'         Name.Function
' '           Text
'root'        Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'elts'        Name.Function
' '           Text
'names'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'cond'        Name.Function
'\n     '     Text
'('           Punctuation
'('           Punctuation
'null? '      Name.Builtin
'elts'        Name.Variable
')'           Punctuation
'\t\t'        Text
'cur'         Name.Variable
')'           Punctuation
'\n     '     Text
'('           Punctuation
'('           Punctuation
'not '        Name.Builtin
'('           Punctuation
'module?'     Name.Function
' '           Text
'cur'         Name.Variable
')'           Punctuation
')'           Punctuation
'\t'          Text
'#f'          Name.Constant
')'           Punctuation
'\n     '     Text
'('           Punctuation
'else '       Keyword
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'module-ref'  Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
' '           Text
'#f'          Name.Constant
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'nested-set!' Name.Function
' '           Text
'root'        Name.Variable
' '           Text
'names'       Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'cur'         Name.Function
' '           Text
'root'        Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'elts'        Name.Function
' '           Text
'names'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'null? '      Name.Builtin
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'module-set!' Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'module-ref'  Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'nested-define!' Name.Function
' '           Text
'root'        Name.Variable
' '           Text
'names'       Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'cur'         Name.Function
' '           Text
'root'        Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'elts'        Name.Function
' '           Text
'names'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'null? '      Name.Builtin
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'module-define!' Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
' '           Text
'val'         Name.Variable
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'module-ref'  Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'nested-remove!' Name.Function
' '           Text
'root'        Name.Variable
' '           Text
'names'       Name.Variable
')'           Punctuation
'\n  '        Text
'('           Punctuation
'let '        Keyword
'loop'        Name.Variable
' '           Text
'('           Punctuation
'('           Punctuation
'cur'         Name.Function
' '           Text
'root'        Name.Variable
')'           Punctuation
'\n\t     '   Text
'('           Punctuation
'elts'        Name.Function
' '           Text
'names'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n    '      Text
'('           Punctuation
'if '         Keyword
'('           Punctuation
'null? '      Name.Builtin
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'module-remove!' Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
'\n\t'        Text
'('           Punctuation
'loop'        Name.Function
' '           Text
'('           Punctuation
'module-ref'  Name.Function
' '           Text
'cur'         Name.Variable
' '           Text
'('           Punctuation
'car '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
' '           Text
'('           Punctuation
'cdr '        Name.Builtin
'elts'        Name.Variable
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
')'           Punctuation
'\n\n'        Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'local-ref'   Name.Function
' '           Text
'names'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'nested-ref'  Name.Function
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
' '           Text
'names'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'local-set!'  Name.Function
' '           Text
'names'       Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'nested-set!' Name.Function
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
' '           Text
'names'       Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'local-define' Name.Function
' '           Text
'names'       Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'nested-define!' Name.Function
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
' '           Text
'names'       Name.Variable
' '           Text
'val'         Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

'('           Punctuation
'define '     Keyword
'('           Punctuation
'local-remove' Name.Function
' '           Text
'names'       Name.Variable
')'           Punctuation
' '           Text
'('           Punctuation
'nested-remove!' Name.Function
' '           Text
'('           Punctuation
'current-module' Name.Function
')'           Punctuation
' '           Text
'names'       Name.Variable
')'           Punctuation
')'           Punctuation
'\n'          Text

';;; boot-9.scm ends here' Comment.Single
'\n'          Text
