(debugger-newline port)
(debugger-newline port)
(let ((names (environment-bound-names environment))
- (package (environment->package environment))
+ (name? (environment-has-name? environment))
(finish
(lambda (names)
(debugger-newline port)
names))))
(cond ((null? names)
(write-string " has no bindings" port))
- ((and package
+ ((and name?
(let ((limit (ref-variable environment-package-limit)))
(and limit
(let ((n (length names)))
#t)))))))
(else
(write-string " BINDINGS:" port)
- (finish (if package (sort names symbol<?) names)))))
+ (finish (if name? (sort names symbol<?) names)))))
(debugger-newline port)
(debugger-newline port)
(write-string
(define (show-environment-name environment port)
(write-string "ENVIRONMENT " port)
- (let ((package (environment->package environment)))
- (if package
+ (let ((name (environment-name environment)))
+ (if name
(begin
(write-string "named: " port)
- (write (package/name package) port))
+ (write name port))
(begin
(write-string "created by " port)
(print-user-friendly-name environment port)))))
ind
port))
names))))
- (cond ((environment->package environment)
+ (cond ((environment-has-name? environment)
(write-string (string-append ind " has ") port)
(write n-bindings port)
(write-string
(write symbol))
(define (apropos-describe-env env)
- (let ((package (environment->package env)))
- (newline)
- (write (or package env))))
\ No newline at end of file
+ (newline)
+ (write (or (environment->package env)
+ (environment->library env)
+ env)))
\ No newline at end of file
(write-string "Depth (relative to initial environment): " port)
(write depth port)
(newline port)))
- (if (not (and (environment->package environment) brief?))
+ (if (not (and (environment-has-name? environment) brief?))
(show-environment-bindings environment brief? port)))
\f
(define (show-environment-name environment port)
(write-string "Environment " port)
- (let ((package (environment->package environment)))
- (if package
+ (let ((name (environment-name environment)))
+ (if name
(begin
(write-string "named: " port)
- (write (package/name package) port))
+ (write name port))
(begin
(write-string "created by " port)
(print-user-friendly-name environment port))))
(define (print-environment environment port)
(newline port)
(show-environment-name environment port)
- (if (not (environment->package environment))
+ (if (not (environment-has-name? environment))
(begin
(newline port)
(let ((arguments (environment-arguments environment)))
result))
(define (special-unbound-name? name)
- (eq? name package-name-tag))
+ (or (eq? name package-name-tag)
+ (eq? name environment-library-tag)))
\f
;;;; Interpreter Environments
make-top-level-environment)
(delete-duplicates (map library-ixport-to imports) eq?))))
(add-imports-to-env! imports env db importing-library)
+ (if importing-library (set-environment->library! env importing-library))
env))
(define (add-imports-to-env! imports env db importing-library)
(nearest-repl/environment)
db
#f)))
+
+(define (environment->library env)
+ (let ((value
+ (and (eq? 'normal
+ (environment-reference-type env environment-library-tag))
+ (environment-lookup env environment-library-tag))))
+ (and (library? value)
+ value)))
+
+(define (set-environment->library! env library)
+ (environment-define env environment-library-tag library))
+
+(define-integrable environment-library-tag
+ '|#[(library database)library-tag]|)
+
+(define (environment-name environment)
+ (cond ((environment->package environment) => package/name)
+ ((environment->library environment) => library-key)
+ (else #f)))
+
+(define (environment-name&type environment)
+ (cond ((environment->package environment)
+ => (lambda (package)
+ (values (package/name package) "package")))
+ ((environment->library environment)
+ => (lambda (library)
+ (values (library-key library) "library")))
+ (else
+ (values #f #f))))
+
+(define (environment-has-name? environment)
+ (or (environment->package environment)
+ (environment->library environment)))
\f
(define (import-sets->imports import-sets db)
(parsed-imports->imports (map parse-import-set import-sets) db))
=> (lambda (name)
(write name port)
(write-string " " port))))
- (cond ((environment->package env)
- => (lambda (package)
- (write (package/name package) port)
- (write-string " " port))))
+ (let ((name (environment-name env)))
+ (if name
+ (begin
+ (write name port)
+ (write-string " " port))))
(write env port))
\f
(define-command 'name '(name)
; Assignments to most compiled-code bindings are prohibited,
; as are certain other environment operations."
port)))
- (let ((package (environment->package environment)))
- (if package
+ (let-values (((name type) (environment-name&type environment)))
+ (if name
(begin
(fresh-line port)
- (write-string ";Package: " port)
- (write (package/name package) port))))))))
+ (write-string ";" port)
+ (write-string type port)
+ (write-string ": " port)
+ (write name port))))))))
\f
(define (restart #!optional n)
(let ((condition (nearest-repl/condition)))
(let ((env-mgr (repl/env-mgr (nearest-repl))))
(let ((env (env-mgr 'current)))
(or (env-mgr 'name-of env)
- (let ((package (environment->package env)))
- (if package
- (package/name package)
- env))))))
+ (or (environment-name env) env)))))
(define (ge #!optional environment)
((repl/env-mgr (nearest-repl))
library-imports
library-imports-environment
library-imports-used
+ library-key
library-name
library-parsed-contents
library-parsed-exports
(parent (runtime library))
(export ()
environment ;(scheme eval)
+ environment->library
+ environment-has-name?
+ environment-name
+ environment-name&type
find-scheme-libraries!
null-environment ;(scheme r5rs)
scheme-report-environment ;(scheme r5rs)
eval-r7rs-source
make-environment-from-parsed-imports
repl-import
- syntax-r7rs-source))
+ syntax-r7rs-source)
+ (export (runtime environment)
+ environment-library-tag))
(define-package (runtime directed-graph)
(files "digraph")
(define (environment-ancestry-names environment)
(let recur ((environment environment))
(if (environment? environment) ;Idle paranoia?
- (let ((package (environment->package environment)))
- (if package
- (list (package/name package))
+ (let ((name (environment-name environment)))
+ (if name
+ (list name)
(let ((name (environment-procedure-name environment))
(names
(if (environment-has-parent? environment)
(package/environment (find-package (read-from-string pstring) #t)))))
(define (env->pstring env)
- (let ((package (environment->package env)))
- (if package
- (write-to-string (package/name package))
+ (let ((name (environment-name env)))
+ (if name
+ (write-to-string name)
(string anonymous-package-prefix (hash-object env)))))
(define anonymous-package-prefix
(iline "cdr" (cdr pair)))))
\f
(define (inspect-environment env)
- (let ((package (environment->package env))
- (tail
+ (let ((tail
(let loop ((bindings (environment-bindings env)))
(if (pair? bindings)
(cons-stream (let ((binding (car bindings)))
(if (environment-has-parent? env)
(stream (iline "(<parent>)" (environment-parent env)))
(stream))))))
- (if package
- (cons-stream (iline "(package)" package) tail)
- tail)))
+ (let-values (((name type) (environment-name&type env)))
+ (if name
+ (cons-stream (iline (string-append "(" type ")") name) tail)
+ tail))))
(define (inspect-vector o)
(let ((len (vector-length o)))
(if (not (default-object? environment))
(begin
(write-string " in environment " output-port)
- (write (cond ((environment->package environment)
- => package/name)
- (else environment))
+ (write (or (environment-name environment)
+ environment)
output-port))))
(lambda ()
(if inline?