@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
@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
(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
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
@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
@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
@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
@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
@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
@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
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
@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
@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
@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
@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
@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
@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
#| -*-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
(declare (usual-integrations))
\f
-(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)
#| -*-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
(else
(ill-formed-syntax form))))))
-(define access-item-rtd
+(define <access-item>
(make-item-type "access-item" '(NAME ENVIRONMENT)
(lambda (item)
(output/access-reference
(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)
#| -*-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
;;; 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)))
;;; 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>))
\f
;;; Keyword items represent macro keywords. There are several flavors
;;; of keyword item.
(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))
\f
;;; 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))
;;; 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)))))
\f
;;; 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)))))
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)))
#| -*-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
(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)
#| -*-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.
(else
(error:wrong-type-argument s "specializer" 'SPECIALIZER-CLASSES))))
\f
-(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)
#| -*-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
(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)))
\f
(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))
(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)
(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)
(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))
\f
-(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)))
(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)
(write-children type)))))
(emit-string ">" ctx))
\f
-(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))
(write-definition (car definitions))))))
(emit-string ">" ctx))
\f
-(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)
(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)
(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)
(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)
(#\& . "&"))
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))
#| -*-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
(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)
(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)
#| -*-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
(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
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?
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?))
projects / mit-scheme.git / commitdiff