scsh-0.6/scheme/env/pedit.scm

356 lines
12 KiB
Scheme

; Copyright (c) 1993-1999 by Richard Kelsey and Jonathan Rees. See file COPYING.
; Package / structure / interface mutation operations.
; None of these is essential for the static semantics of packages.
; They only come into play in order to implement dynamic package
; mutation, which is solely a debugging operation.
; This is work in progress. There are surely numerous bugs.
; (define (package-system-sentinel) #f)
(define (package-open! p struct-thunk)
(if (not (memq (struct-thunk) (package-opens p)))
(let ((thunk (package-opens-thunk p)))
(set-package-opens-thunk! p (lambda ()
(cons (struct-thunk) (thunk))))
(reinitialize-package! p)
(verify-package p)
)))
(define (reinitialize-package! p)
(if *debug?*
(begin (write `(reinitialize ,p)) (newline)))
;; (set-package-opens! p #f)
(if (package-opens-really p)
(initialize-package! p)))
(define (reinitialize-structure! s)
(if *debug?*
(begin (write `(reinitialize ,s)) (newline)))
;; (set-structure-interface! s #f)
(if (structure-interface-really s)
(initialize-structure! s)))
; GET-NEW-LOCATION-CAREFULLY is called to obtain a location when
; a variable becomes newly defined.
; If the variable has already been referenced in any code that ought
; to see the new binding, we need to alter all such references to
; access the new location instead of whatever location they saw
; before.
(define (get-new-location-carefully p name)
(let* ((prev (package-lookup p name))
(new (if (binding? prev)
(let ((new (make-new-location p name))
(cached (table-ref (package-cached p) name)))
(copy-shadowed-contents! (binding-place prev) new)
(cond (cached
(if (eq? (binding-place prev) cached)
(cope-with-mutation p name new cached)
(error "binding cache inconsistency"
p name new cached))))
new)
(get-new-location-non-shadowing p name)))
(aloc (table-ref (package-undefined-but-assigneds p)
name)))
(if aloc ; Assigned?
(begin (if *debug?*
(note "assigned -> defined" name))
(table-set! (package-undefined-but-assigneds p) name #f)
(set-location-forward! aloc new name p)))
new))
(define (note . rest) (apply signal 'note rest))
(define (get-new-location-non-shadowing p name)
(let* ((uloc (table-ref (package-undefineds p) name))
(loc
(if uloc
(begin (if *debug?* (note "undefined -> defined" name uloc))
(table-set! (package-undefineds p) name #f)
uloc)
(make-new-location p name))))
(if (and (not uloc)
(symbol? name)) ; interfaces can't handle generated names
(let recur ((q p))
(let loop ((opens (package-opens q)))
(if (not (null? opens))
(if (interface-ref (structure-interface (car opens)) name)
;; Shadowing
(let* ((q (structure-package (car opens)))
(probe (table-ref (package-undefineds q)
name)))
(if probe
(begin (if *debug?*
(note "undefined -> shadowed"
name loc probe))
(cope-with-mutation p name loc probe))
(recur q)))
(loop (cdr opens)))))))
loc))
; COPE-WITH-MUTATION:
; A package system mutation has newly caused NAME to be bound in
; package P to NEW, but prior references assumed that its binding was
; PREV (perhaps inherited from another package). If PREV is a
; location, then each occurrence of it stowed away in templates and
; packages must eventually be replaced by either location NEW, if P's
; binding is the one that's visible at that occurrence, or to a fresh
; location to replace PREV, if not.
(define (cope-with-mutation p name new prev)
(if (eq? new prev)
(error "lossage in cope-with-mutation" p name new prev))
(let ((replacement (make-new-location p name)))
(copy-location-info! prev replacement)
(table-set! (package-cached p) name new)
(if *debug?*
(begin (write `(mutation ,prev ,new ,replacement)) (newline)))
(shadow-location! prev
(map package-uid
(packages-seeing-location p name prev))
new
replacement)))
;(define (set-binding-place! b foo) (vector-set! b 1 foo))
; Hmm. It ought to be possible to turn this into an RPC.
(define (copy-shadowed-contents! import loc)
(if (location-defined? import)
(set-contents! loc (contents import))))
; Return a list of all packages that might have cached a particular
; inherited binding.
(define (packages-seeing-location package name loc)
(if (not (symbol? name)) ; interfaces cannot handle generated names
(list package)
(let ((losers '())) ; was (list package) but that disables the
; entire procedure
(let recur ((package package))
(if (and (not (memq package losers))
(not (table-ref (package-definitions package) name)))
(begin (set! losers (cons package losers))
(walk-population
(lambda (struct)
(if (interface-ref (structure-interface struct) name)
(walk-population recur (structure-clients struct))))
(package-clients package)))))
losers)))
(define (set-location-forward! loser new name p)
(if *debug?*
(begin (write `(forward ,loser ,new)) (newline)))
(for-each (lambda (q)
(package-note-caching! q name new))
(packages-seeing-location p name loser))
(shadow-location! loser '() #f new))
(set-fluid! $get-location get-new-location-carefully) ;foo
(define (copy-location-info! from to)
(let ((probe (location-info from)))
(if probe
(table-set! location-info-table (location-id to) probe))))
;; Deal with editing operations
(define (really-verify-later! thunk) ;cf. define-structure macro
(let ((loser (ignore-errors thunk)))
(cond ((or (structure? loser)
(interface? loser))
;; (write `(loser: ,loser)) (newline)
(set-fluid! $losers (cons loser (fluid $losers))))))
#f)
(define $losers (make-fluid '()))
(define $package-losers (make-fluid '()))
(define (package-system-sentinel)
(drain $losers verify-loser)
(drain $package-losers verify-package))
(define (verify-loser loser)
(if *debug?*
(begin (write `(verify-loser ,loser)) (newline)))
(cond ((structure? loser)
(reinitialize-structure! loser)
(walk-population
(lambda (p)
(reinitialize-package! p)
(let ((ps (fluid $package-losers)))
(if (not (memq p ps))
(set-fluid! $package-losers
(cons p ps)))))
(structure-clients loser)))
((interface? loser)
(walk-population verify-loser (interface-clients loser)))))
(define (drain flu check)
(let loop ()
(let ((losers (fluid flu)))
(if (not (null? losers))
(let ((loser (car losers)))
(set-fluid! flu (cdr losers))
(check loser)
(loop))))))
(define *debug?* #f)
; --------------------
; If any looked-up location is now invalid, do something about it. We
; might have a previously unbound variable that is now exported by
; some structure; or, we might have a variable that was bound in some
; structure before, but now either that structure doesn't export it at
; all, or we're now getting that binding from some new structure.
(define (verify-package p)
(verify-package-cached p)
(verify-package-undefineds p))
; unbound -> bound
(define (verify-package-undefineds p)
(if *debug?*
(begin (write `(verify undefineds ,p)) (newline)))
(let ((newly-defined '())
(defs (package-definitions p))
(undefs (package-undefineds p)))
(table-walk (lambda (name prev)
(if (table-ref defs name)
(error "lossage in verify-package-undefineds" p name))
(let ((binding (package-lookup p name)))
(if (binding? binding)
(let ((place (binding-place binding)))
(if (eq? place prev)
(error "lossage - verify-package-undefineds"
p name binding))
(set-location-forward! prev place name p)
(set! newly-defined
(cons name newly-defined)))
(let ((loc (location-for-reference p name)))
(if (not (eq? loc prev))
;; Newly imported
(begin (set-location-forward! prev loc name p)
(set! newly-defined
(cons name newly-defined))))))))
undefs)
(if (not (null? newly-defined))
(begin (display "Newly accessible in ")
(write (package-name p))
(display ": ")
(write newly-defined)
(newline)))
(for-each (lambda (winner)
(table-set! undefs winner #f))
newly-defined)))
(define (verify-package-cached p)
;; (write `(verify ,p cached)) (newline)
(let ((newly-moved '())
(newly-undefined '())
(cached (package-cached p)))
(table-walk (lambda (name prev)
(let ((binding (package-lookup p name)))
(if (binding? binding)
(if (not (eq? (binding-place binding) prev))
(set! newly-moved
(cons name newly-moved)))
;; Otherwise either (a) it was previously
;; defined but has become newly undefined, or
;; (b) it was undefined before and is still, but
;; is inherited (or not) from a different place.
(let ((u (location-for-reference p name)))
(if (not (eq? u prev))
(set! newly-undefined
(cons name newly-undefined)))))))
cached)
(if (not (null? newly-moved))
(begin (display "Definitions visible in ")
(write (package-name p))
(display " have moved: ")
(write newly-moved)
(newline)))
(for-each (lambda (name)
(let ((new (binding-place (package-lookup p name))))
(cope-with-mutation p name new
(table-ref cached name))
(table-set! cached name new)))
newly-moved)
(if (and *debug?* (not (null? newly-undefined)))
(begin (display "Newly undefined in ")
(write (package-name p))
(display ": ")
(write newly-undefined)
(newline)))
(for-each (lambda (name)
(let ((new (location-for-reference p name)))
(cope-with-mutation p name new
(table-ref cached name))
(table-set! cached name new)))
newly-undefined)))
(set-verify-later! really-verify-later!)
;(define (maybe-note-redefinition p name seen new)
; (if (and seen (not (compatible? new seen)))
; (let ((old-description (binding-description-string seen))
; (new-description (binding-description-string new))
; (doing (if (package-definition p name)
; "redefining"
; "shadowing")))
; (warn (if (equal? old-description new-description)
; doing
; (string-append doing
; " as "
; new-description
; " (prior references assumed "
; old-description
; ")"))
; name))))
;
;; Foo. This should really set SEEN for all the packages up the
;; inheritance chain.
;
;(define (assume-denotation p name info)
; (if (package-unstable? p) ;***** save space? and time?
; (table-set! (package-seen p) name info))
; info)
;
;; Little utility for warning messages.
;
;(define (binding-description-string d)
; (cond ((transform? d)
; (if (syntax? d) "macro" "integrated procedure"))
; ((operator? d)
; (if (syntax? d) "special operator" "primitive procedure"))
; (else "variable")))
(define (package-undefine! p name)
(let ((probe (table-ref (package-definitions p) name)))
(if probe
(begin (table-set! (package-definitions p) name #f)
(set-location-defined?! (binding-place probe) #f)
(set-location-forward!
(binding-place probe)
(let ((new (package-lookup p name)))
(if (binding? new)
(binding-place new)
(location-for-reference p name)))
name p))
(warn "can't undefine - binding is inherited"
p name))))