From: Chris Hanson <org/chris-hanson/cph>
Date: Sat, 8 Mar 2003 02:16:14 +0000 (+0000)
Subject: Use angle notation for type descriptor.
X-Git-Tag: 20090517-FFI~1978
X-Git-Url: https://birchwood-abbey.net/git?a=commitdiff_plain;h=a27a8f41d23ad6c121bc4d6c90fb0397ab76deb8;p=mit-scheme.git

Use angle notation for type descriptor.
---

diff --git a/v7/doc/ref-manual/scheme.texinfo b/v7/doc/ref-manual/scheme.texinfo
index 4baa7dd0b..78e92be6b 100644
--- a/v7/doc/ref-manual/scheme.texinfo
+++ b/v7/doc/ref-manual/scheme.texinfo
@@ -2,7 +2,7 @@
 @iftex
 @finalout
 @end iftex
-@comment $Id: scheme.texinfo,v 1.121 2003/03/07 06:18:17 cph Exp $
+@comment $Id: scheme.texinfo,v 1.122 2003/03/08 02:10:44 cph Exp $
 @comment %**start of header (This is for running Texinfo on a region.)
 @setfilename scheme.info
 @settitle MIT/GNU Scheme Reference
@@ -51,7 +51,7 @@ Free Documentation License".
 @title{MIT/GNU Scheme Reference Manual}
 @subtitle Edition 1.98
 @subtitle for Scheme Release 7.7.2
-@subtitle 14 February 2003
+@subtitle 7 March 2003
 @author by Chris Hanson
 @author the MIT Scheme Team
 @author and a cast of thousands
@@ -3000,9 +3000,9 @@ different name to hold the type descriptor.
 (define-structure foo a b)
 foo             @result{} #[record-type 18]
 
-(define-structure (bar (type-descriptor bar-rtd)) a b)
+(define-structure (bar (type-descriptor <bar>)) a b)
 bar             @error{} Unbound variable: bar
-bar-rtd         @result{} #[record-type 19]
+<bar>         @result{} #[record-type 19]
 @end group
 @end example
 @end deffn
@@ -16562,7 +16562,7 @@ document.
 Each record type @var{type} has the following associated bindings:
 
 @table @code
-@item @var{type}-rtd
+@item <@var{type}>
 is a variable bound to the record-type descriptor for @var{type}.  The
 record-type descriptor may be used as a specializer in @acronym{SOS}
 method definitions, which greatly simplifies code to dispatch on these
@@ -16593,7 +16593,7 @@ The record's field is modified to have the new value.
 @end table
 
 @deftp {record type} xml-document declaration misc-1 dtd misc-2 root misc-3
-@vindex xml-document-rtd
+@vindex <xml-document>
 @findex xml-document?
 @findex make-xml-document
 @findex xml-document-declaration
@@ -16619,7 +16619,7 @@ or a string of whitespace.
 @end deftp
 
 @deftp {record type} xml-declaration version encoding standalone
-@vindex xml-declaration-rtd
+@vindex <xml-declaration>
 @findex xml-declaration?
 @findex make-xml-declaration
 @findex xml-declaration-version
@@ -16637,7 +16637,7 @@ The @code{xml-declaration} record represents the @samp{<?xml @dots{}
 @end deftp
 
 @deftp {record type} xml-element name attributes contents
-@vindex xml-element-rtd
+@vindex <xml-element>
 @findex xml-element?
 @findex make-xml-element
 @findex xml-element-name
@@ -16659,7 +16659,7 @@ string, an @code{xml-element} record, an
 @end deftp
 
 @deftp {record type} xml-processing-instructions name text
-@vindex xml-processing-instructions-rtd
+@vindex <xml-processing-instructions>
 @findex xml-processing-instructions?
 @findex make-xml-processing-instructions
 @findex xml-processing-instructions-name
@@ -16676,7 +16676,7 @@ instructions (a string).
 @end deftp
 
 @deftp {record type} xml-uninterpreted text
-@vindex xml-uninterpreted-rtd
+@vindex <xml-uninterpreted>
 @findex xml-uninterpreted?
 @findex make-xml-uninterpreted
 @findex xml-uninterpreted-text
@@ -16692,7 +16692,7 @@ text (a string).
 @end deftp
 
 @deftp {record type} xml-dtd root external internal
-@vindex xml-dtd-rtd
+@vindex <xml-dtd>
 @findex xml-dtd?
 @findex make-xml-dtd
 @findex xml-dtd-root
@@ -16711,7 +16711,7 @@ records (e.g.@: @code{xml-!element}, @code{xml-!attlist}, etc.).
 The remaining record types are valid only within a @acronym{DTD}.
 
 @deftp {record type} xml-!element name content-type
-@vindex xml-!element-rtd
+@vindex <xml-!element>
 @findex xml-!element?
 @findex make-xml-!element
 @findex xml-!element-name
@@ -16735,7 +16735,7 @@ A list @samp{(MIX @var{type} @dots{})} corresponds to the
 @end deftp
 
 @deftp {record type} xml-!attlist name definitions
-@vindex xml-!attlist-rtd
+@vindex <xml-!attlist>
 @findex xml-!attlist?
 @findex make-xml-!attlist
 @findex xml-!attlist-name
@@ -16788,7 +16788,7 @@ but might also be an @code{xml-uninterpreted} record.
 @end deftp
 
 @deftp {record type} xml-!entity name value
-@vindex xml-!entity-rtd
+@vindex <xml-!entity>
 @findex xml-!entity?
 @findex make-xml-!entity
 @findex xml-!entity-name
@@ -16802,7 +16802,7 @@ declaration.  @var{Name} is an @acronym{XML} name for the entity.
 @end deftp
 
 @deftp {record type} xml-parameter-!entity name value
-@vindex xml-parameter-!entity-rtd
+@vindex <xml-parameter-!entity>
 @findex xml-parameter-!entity?
 @findex make-xml-parameter-!entity
 @findex xml-parameter-!entity-name
@@ -16816,7 +16816,7 @@ declaration.  @var{Name} is an @acronym{XML} name for the entity.
 @end deftp
 
 @deftp {record type} xml-unparsed-!entity name id notation
-@vindex xml-unparsed-!entity-rtd
+@vindex <xml-unparsed-!entity>
 @findex xml-unparsed-!entity?
 @findex make-xml-unparsed-!entity
 @findex xml-unparsed-!entity-name
@@ -16832,7 +16832,7 @@ declaration.  @code{Name} is an @acronym{XML} name for the entity.
 @end deftp
 
 @deftp {record type} xml-!notation name id
-@vindex xml-!notation-rtd
+@vindex <xml-!notation>
 @findex xml-!notation?
 @findex make-xml-!notation
 @findex xml-!notation-name
@@ -16845,7 +16845,7 @@ The @code{xml-!notation} record represents a notation declaration.
 @end deftp
 
 @deftp {record type} xml-external-id id uri
-@vindex xml-external-id-rtd
+@vindex <xml-external-id>
 @findex xml-external-id?
 @findex make-xml-external-id
 @findex xml-external-id-id
diff --git a/v7/src/runtime/chrset.scm b/v7/src/runtime/chrset.scm
index f1b3cec2a..9a9bba79b 100644
--- a/v7/src/runtime/chrset.scm
+++ b/v7/src/runtime/chrset.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: chrset.scm,v 14.18 2003/02/14 18:28:32 cph Exp $
+$Id: chrset.scm,v 14.19 2003/03/08 02:06:31 cph Exp $
 
 Copyright (c) 1988-2001 Massachusetts Institute of Technology
 
@@ -28,7 +28,7 @@ USA.
 
 (declare (usual-integrations))
 
-(define-structure (char-set (type-descriptor char-set-rtd))
+(define-structure (char-set (type-descriptor <char-set>))
   (table #f read-only #t))
 
 (define-integrable (guarantee-char-set object procedure)
diff --git a/v7/src/runtime/mit-syntax.scm b/v7/src/runtime/mit-syntax.scm
index d3947b138..8660b6138 100644
--- a/v7/src/runtime/mit-syntax.scm
+++ b/v7/src/runtime/mit-syntax.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: mit-syntax.scm,v 14.16 2003/03/06 05:04:56 cph Exp $
+$Id: mit-syntax.scm,v 14.17 2003/03/08 02:06:43 cph Exp $
 
 Copyright 1989,1990,1991,2001,2002,2003 Massachusetts Institute of Technology
 
@@ -846,7 +846,7 @@ USA.
 	    (else
 	     (ill-formed-syntax form))))))
 
-(define access-item-rtd
+(define <access-item>
   (make-item-type "access-item" '(NAME ENVIRONMENT)
     (lambda (item)
       (output/access-reference
@@ -854,16 +854,16 @@ USA.
        (compile-item/expression (access-item/environment item))))))
 
 (define make-access-item
-  (item-constructor access-item-rtd '(NAME ENVIRONMENT)))
+  (item-constructor <access-item> '(NAME ENVIRONMENT)))
 
 (define access-item?
-  (item-predicate access-item-rtd))
+  (item-predicate <access-item>))
 
 (define access-item/name
-  (item-accessor access-item-rtd 'NAME))
+  (item-accessor <access-item> 'NAME))
 
 (define access-item/environment
-  (item-accessor access-item-rtd 'ENVIRONMENT))
+  (item-accessor <access-item> 'ENVIRONMENT))
 
 (define-er-macro-transformer 'CONS-STREAM system-global-environment
   (lambda (form rename compare)
diff --git a/v7/src/runtime/syntactic-closures.scm b/v7/src/runtime/syntactic-closures.scm
index 747cc2aa4..b796dc5aa 100644
--- a/v7/src/runtime/syntactic-closures.scm
+++ b/v7/src/runtime/syntactic-closures.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: syntactic-closures.scm,v 14.14 2003/03/07 21:10:12 cph Exp $
+$Id: syntactic-closures.scm,v 14.15 2003/03/08 02:07:18 cph Exp $
 
 Copyright 1989,1990,1991,2001,2002,2003 Massachusetts Institute of Technology
 
@@ -649,16 +649,16 @@ USA.
 ;;; needed during the cold load.
 
 (define item?
-  (record-predicate item-rtd))
+  (record-predicate <item>))
 
 (define item/history
-  (record-accessor item-rtd 'HISTORY))
+  (record-accessor <item> 'HISTORY))
 
 (define (item/new-history item history)
   (make-item history (item/record item)))
 
 (define item/record
-  (record-accessor item-rtd 'RECORD))
+  (record-accessor <item> 'RECORD))
 
 (define (item=? x y)
   (eq? (item/record x) (item/record y)))
@@ -692,16 +692,16 @@ USA.
 ;;; to signal a meaningful error when one of the <init>s refers to
 ;;; one of the names being bound.
 
-(define reserved-name-item-rtd
+(define <reserved-name-item>
   (make-item-type "reserved-name-item" '()
     (lambda (item)
       (illegal-expression-item item "Reserved name"))))
 
 (define make-reserved-name-item
-  (item-constructor reserved-name-item-rtd '()))
+  (item-constructor <reserved-name-item> '()))
 
 (define reserved-name-item?
-  (item-predicate reserved-name-item-rtd))
+  (item-predicate <reserved-name-item>))
 
 ;;; Keyword items represent macro keywords.  There are several flavors
 ;;; of keyword item.
@@ -719,99 +719,99 @@ USA.
   (illegal-expression-item item "Syntactic keyword"))
 
 
-(define classifier-item-rtd
+(define <classifier-item>
   (make-keyword-type "classifier-item" '(CLASSIFIER)))
 
 (define make-classifier-item
-  (keyword-constructor classifier-item-rtd '(CLASSIFIER)))
+  (keyword-constructor <classifier-item> '(CLASSIFIER)))
 
 (define classifier-item?
-  (item-predicate classifier-item-rtd))
+  (item-predicate <classifier-item>))
 
 (define classifier-item/classifier
-  (item-accessor classifier-item-rtd 'CLASSIFIER))
+  (item-accessor <classifier-item> 'CLASSIFIER))
 
 
-(define compiler-item-rtd
+(define <compiler-item>
   (make-keyword-type "compiler-item" '(COMPILER)))
 
 (define make-compiler-item
-  (keyword-constructor compiler-item-rtd '(COMPILER)))
+  (keyword-constructor <compiler-item> '(COMPILER)))
 
 (define compiler-item?
-  (item-predicate compiler-item-rtd))
+  (item-predicate <compiler-item>))
 
 (define compiler-item/compiler
-  (item-accessor compiler-item-rtd 'COMPILER))
+  (item-accessor <compiler-item> 'COMPILER))
 
 
-(define-item-compiler expander-item-rtd
+(define-item-compiler <expander-item>
   keyword-item-compiler)
 
 (define expander-item?
-  (item-predicate expander-item-rtd))
+  (item-predicate <expander-item>))
 
 (define expander-item/expander
-  (item-accessor expander-item-rtd 'EXPANDER))
+  (item-accessor <expander-item> 'EXPANDER))
 
 (define expander-item/environment
-  (item-accessor expander-item-rtd 'ENVIRONMENT))
+  (item-accessor <expander-item> 'ENVIRONMENT))
 
 
-(define transformer-item-rtd
+(define <transformer-item>
   (make-keyword-type "transformer-item" '(EXPANDER EXPRESSION)))
 
 (define make-transformer-item
-  (keyword-constructor transformer-item-rtd '(EXPANDER EXPRESSION)))
+  (keyword-constructor <transformer-item> '(EXPANDER EXPRESSION)))
 
 (define transformer-item?
-  (item-predicate transformer-item-rtd))
+  (item-predicate <transformer-item>))
 
 (define transformer-item/expander
-  (item-accessor transformer-item-rtd 'EXPANDER))
+  (item-accessor <transformer-item> 'EXPANDER))
 
 (define transformer-item/expression
-  (item-accessor transformer-item-rtd 'EXPRESSION))
+  (item-accessor <transformer-item> 'EXPRESSION))
 
 ;;; Variable items represent run-time variables.
 
-(define variable-item-rtd
+(define <variable-item>
   (make-item-type "variable-item" '(NAME)
     (lambda (item)
       (output/variable (variable-item/name item)))))
 
 (define make-variable-item
-  (let ((constructor (item-constructor variable-item-rtd '(NAME))))
+  (let ((constructor (item-constructor <variable-item> '(NAME))))
     (lambda (name)
       (constructor #f name))))
 
 (define variable-item?
-  (item-predicate variable-item-rtd))
+  (item-predicate <variable-item>))
 
 (define variable-item/name
-  (item-accessor variable-item-rtd 'NAME))
+  (item-accessor <variable-item> 'NAME))
 
 ;;; Expression items represent any kind of expression other than a
 ;;; run-time variable or a sequence.  The ANNOTATION field is used to
 ;;; make expression items that can appear in non-expression contexts
 ;;; (for example, this could be used in the implementation of SETF).
 
-(define expression-item-rtd
+(define <expression-item>
   (make-item-type "expression-item" '(COMPILER ANNOTATION)
     (lambda (item)
       ((expression-item/compiler item)))))
 
 (define make-special-expression-item
-  (item-constructor expression-item-rtd '(COMPILER ANNOTATION)))
+  (item-constructor <expression-item> '(COMPILER ANNOTATION)))
 
 (define expression-item?
-  (item-predicate expression-item-rtd))
+  (item-predicate <expression-item>))
 
 (define expression-item/compiler
-  (item-accessor expression-item-rtd 'COMPILER))
+  (item-accessor <expression-item> 'COMPILER))
 
 (define expression-item/annotation
-  (item-accessor expression-item-rtd 'ANNOTATION))
+  (item-accessor <expression-item> 'ANNOTATION))
 
 (define (make-expression-item history compiler)
   (make-special-expression-item history compiler #f))
@@ -819,40 +819,40 @@ USA.
 ;;; Unassigned items represent the right hand side of a binding that
 ;;; has no explicit value.
 
-(define unassigned-item-rtd
+(define <unassigned-item>
   (make-item-type "unassigned-item" '()
     (lambda (item)
       item				;ignore
       (output/unassigned))))
 
 (define make-unassigned-item
-  (item-constructor unassigned-item-rtd '()))
+  (item-constructor <unassigned-item> '()))
 
 (define unassigned-item?
-  (item-predicate unassigned-item-rtd))
+  (item-predicate <unassigned-item>))
 
 ;;; Declaration items represent block-scoped declarations that are to
 ;;; be passed through to the compiler.
 
-(define declaration-item-rtd
+(define <declaration-item>
   (make-item-type "declaration-item" '(TEXT)
     (lambda (item)
       (illegal-expression-item item "Declaration"))))
 
 (define make-declaration-item
-  (item-constructor declaration-item-rtd '(TEXT)))
+  (item-constructor <declaration-item> '(TEXT)))
 
 (define declaration-item?
-  (item-predicate declaration-item-rtd))
+  (item-predicate <declaration-item>))
 
 (define declaration-item/text
-  (let ((accessor (item-accessor declaration-item-rtd 'TEXT)))
+  (let ((accessor (item-accessor <declaration-item> 'TEXT)))
     (lambda (item)
       ((accessor item)))))
 
 ;;; Body items represent sequences (e.g. BEGIN).
 
-(define body-item-rtd
+(define <body-item>
   (make-item-type "body-item" '(COMPONENTS)
     (lambda (item)
       (compile-body-items item (body-item/components item)))))
@@ -873,45 +873,45 @@ USA.
 	  items))))
 
 (define make-body-item
-  (item-constructor body-item-rtd '(COMPONENTS)))
+  (item-constructor <body-item> '(COMPONENTS)))
 
 (define body-item?
-  (item-predicate body-item-rtd))
+  (item-predicate <body-item>))
 
 (define body-item/components
-  (item-accessor body-item-rtd 'COMPONENTS))
+  (item-accessor <body-item> 'COMPONENTS))
 
 ;;; Binding items represent definitions, whether top-level or
 ;;; internal, keyword or variable.  Null binding items are for
 ;;; definitions that don't emit code.
 
-(define binding-item-rtd
+(define <binding-item>
   (make-item-type "binding-item" '(NAME VALUE)
     (lambda (item)
       (illegal-expression-item item "Definition"))))
 
 (define make-binding-item
-  (item-constructor binding-item-rtd '(NAME VALUE)))
+  (item-constructor <binding-item> '(NAME VALUE)))
 
 (define binding-item?
-  (item-predicate binding-item-rtd))
+  (item-predicate <binding-item>))
 
 (define binding-item/name
-  (item-accessor binding-item-rtd 'NAME))
+  (item-accessor <binding-item> 'NAME))
 
 (define binding-item/value
-  (item-accessor binding-item-rtd 'VALUE))
+  (item-accessor <binding-item> 'VALUE))
 
-(define null-binding-item-rtd
+(define <null-binding-item>
   (make-item-type "null-binding-item" '()
     (lambda (item)
       (illegal-expression-item item "Definition"))))
 
 (define make-null-binding-item
-  (item-constructor null-binding-item-rtd '()))
+  (item-constructor <null-binding-item> '()))
 
 (define null-binding-item?
-  (item-predicate null-binding-item-rtd))
+  (item-predicate <null-binding-item>))
 
 (define (bind-variable! environment name)
   (let ((rename (syntactic-environment/rename environment name)))
diff --git a/v7/src/runtime/syntax-transforms.scm b/v7/src/runtime/syntax-transforms.scm
index b138d15f8..765638d6c 100644
--- a/v7/src/runtime/syntax-transforms.scm
+++ b/v7/src/runtime/syntax-transforms.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: syntax-transforms.scm,v 14.5 2003/02/14 18:48:13 cph Exp $
+$Id: syntax-transforms.scm,v 14.6 2003/03/08 02:07:26 cph Exp $
 
 Copyright 1989-1991, 2001, 2002 Massachusetts Institute of Technology
 
@@ -42,20 +42,20 @@ USA.
     (lambda arguments
       (apply constructor #f arguments))))
 
-(define item-rtd)
+(define <item>)
 (define make-item)
-(define expander-item-rtd)
+(define <expander-item>)
 (define make-expander-item)
 
 (define (initialize-syntax-transforms!)
-  (set! item-rtd
+  (set! <item>
 	(make-record-type "item" '(HISTORY RECORD)))
   (set! make-item
-	(record-constructor item-rtd '(HISTORY RECORD)))
-  (set! expander-item-rtd
+	(record-constructor <item> '(HISTORY RECORD)))
+  (set! <expander-item>
 	(make-record-type "expander-item" '(EXPANDER ENVIRONMENT)))
   (set! make-expander-item
-	(keyword-constructor expander-item-rtd '(EXPANDER ENVIRONMENT)))
+	(keyword-constructor <expander-item> '(EXPANDER ENVIRONMENT)))
   unspecific)
 
 (define (sc-macro-transformer->expander transformer closing-environment)
diff --git a/v7/src/sos/method.scm b/v7/src/sos/method.scm
index d07732b60..c794aebec 100644
--- a/v7/src/sos/method.scm
+++ b/v7/src/sos/method.scm
@@ -1,8 +1,8 @@
 #| -*-Scheme-*-
 
-$Id: method.scm,v 1.14 2003/02/14 18:28:35 cph Exp $
+$Id: method.scm,v 1.15 2003/03/08 02:16:14 cph Exp $
 
-Copyright 1995-1999 Massachusetts Institute of Technology
+Copyright 1995,1997,2003 Massachusetts Institute of Technology
 
 This file is part of MIT/GNU Scheme.
 
@@ -321,7 +321,7 @@ USA.
 	(else
 	 (error:wrong-type-argument s "specializer" 'SPECIALIZER-CLASSES))))
 
-(define-structure (union-specializer (type-descriptor union-specializer-rtd))
+(define-structure (union-specializer (type-descriptor <union-specializer>))
   (classes #f read-only #t))
 
 (define (union-specializer . specializers)
diff --git a/v7/src/xml/xml-output.scm b/v7/src/xml/xml-output.scm
index 3219fc3a5..098cff47d 100644
--- a/v7/src/xml/xml-output.scm
+++ b/v7/src/xml/xml-output.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: xml-output.scm,v 1.16 2003/03/05 01:14:40 cph Exp $
+$Id: xml-output.scm,v 1.17 2003/03/08 02:14:18 cph Exp $
 
 Copyright 2001,2002,2003 Massachusetts Institute of Technology
 
@@ -48,7 +48,7 @@ USA.
 (define (write-xml-1 xml port options)
   (%write-xml xml (make-ctx port options)))
 
-(define-structure (ctx (type-descriptor ctx-rtd)
+(define-structure (ctx (type-descriptor <ctx>)
 		       (keyword-constructor %make-ctx)
 		       (print-procedure
 			(standard-unparser-method 'XML-OUTPUT-CONTEXT #f)))
@@ -80,7 +80,7 @@ USA.
 
 (define-generic %write-xml (object ctx))
 
-(define-method %write-xml ((document xml-document-rtd) ctx)
+(define-method %write-xml ((document <xml-document>) ctx)
   (if (xml-document-declaration document)
       (%write-xml (xml-document-declaration document) ctx))
   (for-each (lambda (object) (%write-xml object ctx))
@@ -93,7 +93,7 @@ USA.
   (for-each (lambda (object) (%write-xml object ctx))
 	    (xml-document-misc-3 document)))
 
-(define-method %write-xml ((declaration xml-declaration-rtd) ctx)
+(define-method %write-xml ((declaration <xml-declaration>) ctx)
   (emit-string "<?xml version=\"" ctx)
   (emit-string (xml-declaration-version declaration) ctx)
   (emit-string "\"" ctx)
@@ -109,7 +109,7 @@ USA.
 	(emit-string "\"" ctx)))
   (emit-string "?>" ctx))
 
-(define-method %write-xml ((element xml-element-rtd) ctx)
+(define-method %write-xml ((element <xml-element>) ctx)
   (let ((name (xml-element-name element))
 	(contents (xml-element-contents element)))
     (emit-string "<" ctx)
@@ -127,18 +127,18 @@ USA.
 	  (emit-string ">" ctx))
 	(emit-string " />" ctx))))
 
-(define-method %write-xml ((comment xml-comment-rtd) ctx)
+(define-method %write-xml ((comment <xml-comment>) ctx)
   (emit-string "<!--" ctx)
   (emit-string (xml-comment-text comment) ctx)
   (emit-string "-->" ctx))
 
-(define-method %write-xml ((pi xml-processing-instructions-rtd) ctx)
+(define-method %write-xml ((pi <xml-processing-instructions>) ctx)
   (emit-string "<?" ctx)
   (write-xml-name (xml-processing-instructions-name pi) ctx)
   (emit-string (xml-processing-instructions-text pi) ctx)
   (emit-string "?>" ctx))
 
-(define-method %write-xml ((dtd xml-dtd-rtd) ctx)
+(define-method %write-xml ((dtd <xml-dtd>) ctx)
   ;;root external internal
   (emit-string "<!DOCTYPE " ctx)
   (let ((col (ctx-start-col ctx)))
@@ -159,7 +159,7 @@ USA.
 	  (emit-string "]" ctx)))
     (emit-string ">" ctx)))
 
-(define-method %write-xml ((decl xml-!element-rtd) ctx)
+(define-method %write-xml ((decl <xml-!element>) ctx)
   (emit-string "<!ELEMENT " ctx)
   (write-xml-name (xml-!element-name decl) ctx)
   (emit-string " " ctx)
@@ -217,7 +217,7 @@ USA.
 	     (write-children type)))))
   (emit-string ">" ctx))
 
-(define-method %write-xml ((decl xml-!attlist-rtd) ctx)
+(define-method %write-xml ((decl <xml-!attlist>) ctx)
   (emit-string "<!ATTLIST " ctx)
   (write-xml-name (xml-!attlist-name decl) ctx)
   (let ((definitions (xml-!attlist-definitions decl))
@@ -276,7 +276,7 @@ USA.
 	      (write-definition (car definitions))))))
   (emit-string ">" ctx))
 
-(define-method %write-xml ((decl xml-!entity-rtd) ctx)
+(define-method %write-xml ((decl <xml-!entity>) ctx)
   (emit-string "<!ENTITY " ctx)
   (let ((col (ctx-start-col ctx)))
     (write-xml-name (xml-!entity-name decl) ctx)
@@ -284,7 +284,7 @@ USA.
     (write-entity-value (xml-!entity-value decl) col ctx)
     (emit-string ">" ctx)))
 
-(define-method %write-xml ((decl xml-unparsed-!entity-rtd) ctx)
+(define-method %write-xml ((decl <xml-unparsed-!entity>) ctx)
   (emit-string "<!ENTITY " ctx)
   (let ((col (ctx-start-col ctx)))
     (write-xml-name (xml-unparsed-!entity-name decl) ctx)
@@ -294,7 +294,7 @@ USA.
     (write-xml-name (xml-unparsed-!entity-notation decl) ctx)
     (emit-string ">" ctx)))
 
-(define-method %write-xml ((decl xml-parameter-!entity-rtd) ctx)
+(define-method %write-xml ((decl <xml-parameter-!entity>) ctx)
   (emit-string "<!ENTITY " ctx)
   (let ((col (ctx-start-col ctx)))
     (emit-string "% " ctx)
@@ -303,7 +303,7 @@ USA.
     (write-entity-value (xml-parameter-!entity-value decl) col ctx)
     (emit-string ">" ctx)))
 
-(define-method %write-xml ((decl xml-!notation-rtd) ctx)
+(define-method %write-xml ((decl <xml-!notation>) ctx)
   (emit-string "<!NOTATION " ctx)
   (let ((col (ctx-start-col ctx)))
     (write-xml-name (xml-!notation-name decl) ctx)
@@ -317,12 +317,12 @@ USA.
 			  (#\& . "&amp;"))
 			ctx))
 
-(define-method %write-xml ((ref xml-entity-ref-rtd) ctx)
+(define-method %write-xml ((ref <xml-entity-ref>) ctx)
   (emit-string "&" ctx)
   (write-xml-name (xml-entity-ref-name ref) ctx)
   (emit-string ";" ctx))
 
-(define-method %write-xml ((ref xml-parameter-entity-ref-rtd) ctx)
+(define-method %write-xml ((ref <xml-parameter-entity-ref>) ctx)
   (emit-string "%" ctx)
   (write-xml-name (xml-parameter-entity-ref-name ref) ctx)
   (emit-string ";" ctx))
diff --git a/v7/src/xml/xml-struct.scm b/v7/src/xml/xml-struct.scm
index 9d81688f3..bc2779669 100644
--- a/v7/src/xml/xml-struct.scm
+++ b/v7/src/xml/xml-struct.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: xml-struct.scm,v 1.11 2003/03/02 03:48:47 cph Exp $
+$Id: xml-struct.scm,v 1.12 2003/03/08 02:14:25 cph Exp $
 
 Copyright 2001,2002,2003 Massachusetts Institute of Technology
 
@@ -77,7 +77,7 @@ USA.
      (if (syntax-match? '(IDENTIFIER * (IDENTIFIER EXPRESSION)) (cdr form))
 	 (let ((root (symbol-append 'XML- (cadr form)))
 	       (slots (cddr form)))
-	   (let ((rtd (symbol-append root '-RTD))
+	   (let ((rtd (symbol-append '< root '>))
 		 (constructor (symbol-append 'MAKE- root))
 		 (slot-vars
 		  (map (lambda (slot)
@@ -343,7 +343,7 @@ USA.
 	       (accessor (caddr form)))
 	   (let ((root (symbol-append 'XML- name)))
 	     `(SET-RECORD-TYPE-UNPARSER-METHOD!
-	       ,(close-syntax (symbol-append root '-RTD) environment)
+	       ,(close-syntax (symbol-append '< root '>) environment)
 	       (STANDARD-UNPARSER-METHOD ',root
 		 (LAMBDA (,name PORT)
 		   (WRITE-CHAR #\SPACE PORT)
diff --git a/v7/src/xml/xml.pkg b/v7/src/xml/xml.pkg
index ee21cefd9..a6fcb2eae 100644
--- a/v7/src/xml/xml.pkg
+++ b/v7/src/xml/xml.pkg
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Id: xml.pkg,v 1.18 2003/03/05 01:15:13 cph Exp $
+$Id: xml.pkg,v 1.19 2003/03/08 02:14:11 cph Exp $
 
 Copyright 2001,2002,2003 Massachusetts Institute of Technology
 
@@ -36,6 +36,21 @@ USA.
   (files "xml-struct")
   (parent (runtime xml))
   (export ()
+	  <xml-!attlist>
+	  <xml-!element>
+	  <xml-!entity>
+	  <xml-!notation>
+	  <xml-comment>
+	  <xml-declaration>
+	  <xml-document>
+	  <xml-dtd>
+	  <xml-element>
+	  <xml-entity-ref>
+	  <xml-external-id>
+	  <xml-parameter-!entity>
+	  <xml-parameter-entity-ref>
+	  <xml-processing-instructions>
+	  <xml-unparsed-!entity>
 	  make-xml-!attlist
 	  make-xml-!element
 	  make-xml-!entity
@@ -88,25 +103,19 @@ USA.
 	  set-xml-unparsed-!entity-notation!
 	  xml-!attlist-definitions
 	  xml-!attlist-name
-	  xml-!attlist-rtd
 	  xml-!attlist?
 	  xml-!element-content-type
 	  xml-!element-name
-	  xml-!element-rtd
 	  xml-!element?
 	  xml-!entity-name
-	  xml-!entity-rtd
 	  xml-!entity-value
 	  xml-!entity?
 	  xml-!notation-id
 	  xml-!notation-name
-	  xml-!notation-rtd
 	  xml-!notation?
-	  xml-comment-rtd
 	  xml-comment-text
 	  xml-comment?
 	  xml-declaration-encoding
-	  xml-declaration-rtd
 	  xml-declaration-standalone
 	  xml-declaration-version
 	  xml-declaration?
@@ -116,43 +125,34 @@ USA.
 	  xml-document-misc-2
 	  xml-document-misc-3
 	  xml-document-root
-	  xml-document-rtd
 	  xml-document?
 	  xml-dtd-external
 	  xml-dtd-internal
 	  xml-dtd-root
-	  xml-dtd-rtd
 	  xml-dtd?
 	  xml-element-attributes
 	  xml-element-contents
 	  xml-element-name
-	  xml-element-rtd
 	  xml-element?
 	  xml-entity-ref-name
-	  xml-entity-ref-rtd
 	  xml-entity-ref?
 	  xml-external-id-id
-	  xml-external-id-rtd
 	  xml-external-id-uri
 	  xml-external-id?
 	  xml-intern
 	  xml-name?
 	  xml-nmtoken?
 	  xml-parameter-!entity-name
-	  xml-parameter-!entity-rtd
 	  xml-parameter-!entity-value
 	  xml-parameter-!entity?
 	  xml-parameter-entity-ref-name
-	  xml-parameter-entity-ref-rtd
 	  xml-parameter-entity-ref?
 	  xml-processing-instructions-name
-	  xml-processing-instructions-rtd
 	  xml-processing-instructions-text
 	  xml-processing-instructions?
 	  xml-unparsed-!entity-id
 	  xml-unparsed-!entity-name
 	  xml-unparsed-!entity-notation
-	  xml-unparsed-!entity-rtd
 	  xml-unparsed-!entity?
 	  xml-whitespace-string?))