| xml editor |
|
The mechanism for encoding character code points into bit patterns MAY vary from entity to entity. All XML processors MUST accept the UTF-8 and UTF-16 encodings of Unicode 3.1 [Unicode3]; the mechanisms for signaling which of the two is in use, or for bringing other encodings into play, are discussed later, in 4.3.3 Character Encoding in Entities. Example Document authors are encouraged to avoid
"compatibility characters", as defined
in section 6.8 of [Unicode] (see also D21 in section 3.6 of
[Unicode3]). The characters defined in the following ranges are also
discouraged. They are either control characters or permanently undefined Unicode
characters: [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF], [#1FFFE-#x1FFFF], [#2FFFE-#x2FFFF], [#3FFFE-#x3FFFF], [#4FFFE-#x4FFFF], [#5FFFE-#x5FFFF], [#6FFFE-#x6FFFF], [#7FFFE-#x7FFFF], [#8FFFE-#x8FFFF], [#9FFFE-#x9FFFF], [#AFFFE-#xAFFFF], [#BFFFE-#xBFFFF], [#CFFFE-#xCFFFF], [#DFFFE-#xDFFFF], [#EFFFE-#xEFFFF], [#FFFFE-#xFFFFF], [#10FFFE-#x10FFFF].
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| White Space | ||||
|
Characters are classified for convenience as letters, digits, or other characters. A letter consists of an alphabetic or syllabic base character or an ideographic character. Full definitions of the specific characters in each class are given in B Character Classes.
[Definition:] A Name is a token beginning
with a letter or one of a few punctuation characters, and continuing with
letters, digits, hyphens, underscores, colons, or full stops, together known
as name characters. Names beginning with the string "xml",
or with any string which would match (('X'|'x') ('M'|'m') ('L'|'l')),
are reserved for standardization in this or future versions of this specification.
An Nmtoken (name token) is any mixture of name characters.
| Names and Tokens | ||||||||||||||||||||||
|
Literal data is any quoted string not containing the quotation mark used as a delimiter for that string. Literals are used for specifying the content of internal entities (EntityValue), the values of attributes (AttValue), and external identifiers (SystemLiteral). Note that a SystemLiteral can be parsed without scanning for markup.
| Literals | ||||||||||||||||||||||||||||
|
Mac OS X
Linux/Unix< in the literal
(e.g., <!ENTITY mylt "<">), it is strongly advised to avoid
this practice since any reference to that entity will cause a well-formedness
error.
2.4 Character Data and Markup·Text· consists of intermingled ·character data· and markup. [Definition:] Markup takes the form of ·start-tags·, ·end-tags·, ·empty-element tags·, ·entity references·, ·character references·, ·comments·, ·CDATA section· delimiters, ·document type declarations·, ·processing instructions·, XML declarations, text declarations, and any white space that is at the top level of the document entity (that is, outside the document element and not inside any other markup).
[Definition:] All text that is not markup constitutes the character data of the document.
The ampersand character (&) and the left angle bracket (<) MUST NOT appear
in their literal form, except when used as markup delimiters, or
within a ·comment·, a ·processing
instruction·, or a ·CDATA section·.
If they are needed elsewhere, they MUST be ·escaped·
using either ·numeric character references·
or the strings "&" and "<"
respectively. The right angle bracket (>) MAY be represented using the string ">",
and MUST, ·for compatibility·, be escaped
using either ">" or a character reference when it
appears in the string "]]>" in content, when
that string is not marking the end of a ·CDATA
section·.
In the content of elements, character data is any string of characters
which does not contain the start-delimiter of any markup and does not include the CDATA-section-close
delimiter, "]]>". In a CDATA section,
character data is any string of characters not including the CDATA-section-close
delimiter, "]]>".
To allow attribute values to contain both single and double quotes, the
apostrophe or single-quote character (') MAY be represented as "'",
and the double-quote character (") as """.
| Character Data | ||||
|
2.5 Comments[Definition:] Comments MAY appear
anywhere in a document outside other ·markup·;
in addition, they MAY appear within the document type declaration at places
allowed by the grammar. They are not part of the document's ·character
data·; an XML processor MAY, but need not, make it possible for an
application to retrieve the text of comments. ·For
compatibility·, the string "--" (double-hyphen)
MUST NOT occur within comments. Parameter
entity references MUST NOT be recognized within comments.
| Comments | ||||
|
An example of a comment:
<!-- declarations for <head> & <body> -->
Note
that the grammar does not allow a comment ending in --->. The
following example is not well-formed.
<!-- B+, B, or B--->
2.6 Processing Instructions[Definition:] Processing instructions (PIs) allow documents to contain instructions for applications.
| Processing Instructions | ||||||||
|
PIs are not part of the document's ·character
data·, but MUST be passed through to the application. The PI begins
with a target (PITarget) used to identify the application
to which the instruction is directed. The target names "XML", "xml",
and so on are reserved for standardization in this or future versions of this
specification. The XML ·Notation· mechanism
MAY be used for formal declaration of PI targets. Parameter
entity references MUST NOT be recognized within processing instructions.
2.7 CDATA Sections[Definition:] CDATA sections MAY occur anywhere character data may occur; they are used to escape blocks
of text containing characters which would otherwise be recognized as markup.
CDATA sections begin with the string "<![CDATA["
and end with the string "]]>":
| CDATA Sections | ||||||||||||||||
|
Within a CDATA section, only the CDEnd string is
recognized as markup, so that left angle brackets and ampersands may occur
in their literal form; they need not (and cannot) be escaped using "<"
and "&". CDATA sections cannot nest.
An example of a CDATA section, in which "<greeting>"
and "</greeting>" are recognized as ·character data·, not ·markup·:
<![CDATA[<greeting>Hello, world!</greeting>]]>
2.8 Prolog and Document Type Declaration[Definition:] XML documents SHOULD begin with an XML declaration which specifies the version of XML being used. For example, the following is a complete XML document, ·well-formed· but not ·valid·:
<?xml version="1.0"?> <greeting>Hello, world!</greeting>
and so is this:
<greeting>Hello, world!</greeting>
The function of the markup in an XML document is to describe its storage and logical structure and to associate attribute name-value pairs with its logical structures. XML provides a mechanism, the ·document type declaration·, to define constraints on the logical structure and to support the use of predefined storage units. [Definition:] An XML document is valid if it has an associated document type declaration and if the document complies with the constraints expressed in it.
The document type declaration MUST appear before the first ·element· in the document.
| Prolog | |||||||||||||||||||||||
|
[Definition:] The XML document type declaration contains or points to ·markup declarations· that provide a grammar for a class of documents. This grammar is known as a document type definition, or DTD. The document type declaration can point to an external subset (a special kind of ·external entity·) containing markup declarations, or can contain the markup declarations directly in an internal subset, or can do both. The DTD for a document consists of both subsets taken together.
[Definition:] A markup declaration is an ·element type declaration·, an ·attribute-list declaration·, an ·entity declaration·, or a ·notation declaration·. These declarations MAY be contained in whole or in part within ·parameter entities·, as described in the well-formedness and validity constraints below. For further information, see 4 Physical Structures.
| Document Type Definition | |||||||||||||||||||||||||||||||||
|
Note that it is possible to construct a well-formed document containing a doctypedecl that neither points to an external subset nor contains an internal subset.
The markup declarations MAY be made up in whole or in part of the ·replacement text· of ·parameter entities·. The productions later in this specification for individual nonterminals (elementdecl, AttlistDecl, and so on) describe the declarations after all the parameter entities have been ·included·.
Parameter entity references are recognized anywhere in the DTD (internal and external subsets and external parameter entities), except in literals, processing instructions, comments, and the contents of ignored conditional sections (see 3.4 Conditional Sections). They are also recognized in entity value literals. The use of parameter entities in the internal subset is restricted as described below.
Validity constraint: Root Element Type
The Name in the document type declaration MUST match the element type of the ·root element·.
Validity constraint: Proper Declaration/PE Nesting
Parameter-entity ·replacement text· MUST be properly nested with markup declarations. That is to say, if either the first character or the last character of a markup declaration (markupdecl above) is contained in the replacement text for a ·parameter-entity reference·, both MUST be contained in the same replacement text.
Well-formedness constraint: PEs in Internal Subset
In the internal DTD subset, ·parameter-entity references· MUST NOT occur within markup declarations; they MAY occur where markup declarations can occur. (This does not apply to references that occur in external parameter entities or to the external subset.)
Well-formedness constraint: External Subset
The external subset, if any, MUST match the production for extSubset.
Well-formedness constraint: PE Between Declarations
The replacement text of a parameter entity reference in a DeclSep MUST match the production extSubsetDecl.
Like the internal subset, the external subset and any external parameter entities referenced in a DeclSep MUST consist of a series of complete markup declarations of the types allowed by the non-terminal symbol markupdecl, interspersed with white space or ·parameter-entity references·. However, portions of the contents of the external subset or of these external parameter entities MAY conditionally be ignored by using the ·conditional section· construct; this is not allowed in the internal subset but is allowed in external parameter entities referenced in the internal subset.
| External Subset | ||||||||
|
The external subset and external parameter entities also differ from the internal subset in that in them, ·parameter-entity references· are permitted within markup declarations, not only between markup declarations.
An example of an XML document with a document type declaration:
<?xml version="1.0"?> <!DOCTYPE greeting SYSTEM "hello.dtd"> <greeting>Hello, world!</greeting>
The ·system identifier· "hello.dtd"
gives the address (a URI reference) of a DTD for the document.
The declarations can also be given locally, as in this example:
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE greeting [ <!ELEMENT greeting (#PCDATA)> ]> <greeting>Hello, world!</greeting>
If both the external and internal subsets are used, the internal subset MUST be considered to occur before the external subset. This has the effect that entity and attribute-list declarations in the internal subset take precedence over those in the external subset.
2.9 Standalone Document DeclarationMarkup declarations can affect the content of the document, as passed from an ·XML processor· to an application; examples are attribute defaults and entity declarations. The standalone document declaration, which MAY appear as a component of the XML declaration, signals whether or not there are such declarations which appear external to the ·document entity· or in parameter entities. [Definition:] An external markup declaration is defined as a markup declaration occurring in the external subset or in a parameter entity (external or internal, the latter being included because non-validating processors are not required to read them).
| Standalone Document Declaration | |||||
|
In a standalone document declaration, the value "yes" indicates that there are no ·external markup declarations· which affect the information passed from the XML processor to the application. The value "no" indicates that there are or may be such external markup declarations. Note that the standalone document declaration only denotes the presence of external declarations; the presence, in a document, of references to external entities, when those entities are internally declared, does not change its standalone status.
If there are no external markup declarations, the standalone document declaration has no meaning. If there are external markup declarations but there is no standalone document declaration, the value "no" is assumed.
Any XML document for which standalone="no" holds can be converted
algorithmically to a standalone document, which may be desirable for some
network delivery applications.
Validity constraint: Standalone Document Declaration
The standalone document declaration MUST have the value "no" if any external markup declarations contain declarations of:
amp,
lt,
gt,
apos,
quot), if ·references·
to those entities appear in the document, orAn example XML declaration with a standalone document declaration:
<?xml version="1.0" standalone='yes'?>
2.10 White Space HandlingIn editing XML documents, it is often convenient to use "white space" (spaces, tabs, and blank lines) to set apart the markup for greater readability. Such white space is typically not intended for inclusion in the delivered version of the document. On the other hand, "significant" white space that should be preserved in the delivered version is common, for example in poetry and source code.
An ·XML processor· MUST always pass all characters in a document that are not markup through to the application. A · validating XML processor· MUST also inform the application which of these characters constitute white space appearing in ·element content·.
A special ·attribute· named xml:space MAY be attached to an element to signal an intention that in that element,
white space should be preserved by applications. In valid documents, this
attribute, like any other, MUST be ·declared·
if it is used. When declared, it MUST be given as an ·enumerated
type· whose values
are one or both of "default" and "preserve".
For example:
<!ATTLIST poem xml:space (default|preserve) 'preserve'> <!ATTLIST pre xml:space (preserve) #FIXED 'preserve'>
The value "default" signals that applications' default white-space
processing modes are acceptable for this element; the value "preserve"
indicates the intent that applications preserve all the white space. This
declared intent is considered to apply to all elements within the content
of the element where it is specified, unless overridden with
another instance of the xml:space attribute. This specification does not give meaning to any value of xml:space other than "default" and "preserve". It is an error for other values to be specified; the XML processor MAY report the error or MAY recover by ignoring the attribute specification or by reporting the (erroneous) value to the application. Applications may ignore or reject erroneous values.
The ·root element· of any document is considered to have signaled no intentions as regards application space handling, unless it provides a value for this attribute or the attribute is declared with a default value.
2.11 End-of-Line HandlingXML ·parsed entities· are often stored in computer files which, for editing convenience, are organized into lines. These lines are typically separated by some combination of the characters CARRIAGE RETURN (#xD) and LINE FEED (#xA).
To simplify the tasks of ·applications·, the ·XML processor· MUST behave as if it normalized all line breaks in external parsed entities (including the document entity) on input, before parsing, by translating both the two-character sequence #xD #xA and any #xD that is not followed by #xA to a single #xA character.
2.12 Language IdentificationIn document processing, it is often useful to identify the natural or formal
language in which the content is written. A special ·attribute·
named xml:lang MAY be inserted in documents to specify the language
used in the contents and attribute values of any element in an XML document.
In valid documents, this attribute, like any other, MUST be ·declared·
if it is used. The
values of the attribute are language identifiers as defined by [IETF RFC 3066], Tags
for the Identification of Languages, or its successor; in addition, the empty string MAY be specified.
(Productions 33 through 38 have been removed.)
For example:
<p xml:lang="en">The quick brown fox jumps over the lazy dog.</p> <p xml:lang="en-GB">What colour is it?</p> <p xml:lang="en-US">What color is it?</p> <sp who="Faust" desc='leise' xml:lang="de"> <l>Habe nun, ach! Philosophie,</l> <l>Juristerei, und Medizin</l> <l>und leider auch Theologie</l> <l>durchaus studiert mit heißem Bemüh'n.</l> </sp>
The intent declared with xml:lang is considered to apply to
all attributes and content of the element where it is specified, unless overridden
with an instance of xml:lang on another element within that content. In particular, the empty value of xml:lang is used on an element B to override a specification of xml:lang on an enclosing element A, without specifying another language. Within B, it is considered that there is no language information available, just as if xml:lang had not been specified on B or any of its ancestors.
xml:lang should be considered to override it.
A simple declaration for xml:lang might take the form
xml:lang CDATA #IMPLIED
but specific default values MAY also be given, if appropriate. In a collection
of French poems for English students, with glosses and notes in English, the xml:lang
attribute might be declared this way:
<!ATTLIST poem xml:lang CDATA 'fr'> <!ATTLIST gloss xml:lang CDATA 'en'> <!ATTLIST note xml:lang CDATA 'en'>
[Definition:] Each ·XML document· contains one or more elements, the boundaries of which are either delimited by ·start-tags· and ·end-tags·, or, for ·empty· elements, by an ·empty-element tag·. Each element has a type, identified by name, sometimes called its "generic identifier" (GI), and MAY have a set of attribute specifications. Each attribute specification has a ·name· and a ·value·.
| Element | ||||||||||||||
|
This specification does not constrain the semantics, use, or (beyond syntax)
names of the element types and attributes, except that names beginning with
a match to (('X'|'x')('M'|'m')('L'|'l')) are reserved for standardization
in this or future versions of this specification.
Well-formedness constraint: Element Type Match
The Name in an element's end-tag MUST match the element type in the start-tag.
Validity constraint: Element Valid
An element is valid if there is a declaration matching elementdecl where the Name matches the element type, and one of the following holds:
3.1 Start-Tags, End-Tags, and Empty-Element Tags[Definition:] The beginning of every non-empty XML element is marked by a start-tag.
| Start-tag | ||||||||||||||||||||
|
The Name in the start- and end-tags gives the element's type. [Definition:] The Name-AttValue
pairs are referred to as the attribute specifications of the
element, [Definition:] with the Name in each pair referred to as the attribute name
and [Definition:] the content of the AttValue (the text between the ' or "
delimiters) as the attribute value. Note
that the order of attribute specifications in a start-tag or empty-element
tag is not significant.
Well-formedness constraint: Unique Att Spec
An attribute name MUST NOT appear more than once in the same start-tag or empty-element tag.
Validity constraint: Attribute Value Type
The attribute MUST have been declared; the value MUST be of the type declared for it. (For attribute types, see 3.3 Attribute-List Declarations.)
Well-formedness constraint: No External Entity References
Attribute values MUST NOT contain direct or indirect entity references to external entities.
Well-formedness constraint: No < in Attribute Values
The ·replacement text· of any entity
referred to directly or indirectly in an attribute value MUST NOT contain a <.
An example of a start-tag:
<termdef id="dt-dog" term="dog">
[Definition:] The end of every element that begins with a start-tag MUST be marked by an end-tag containing a name that echoes the element's type as given in the start-tag:
| End-tag | ||||
|
An example of an end-tag:
</termdef>
[Definition:] The ·text· between the start-tag and end-tag is called the element's content:
| Content of Elements | ||||
|
[Definition:] An element with no content is said to be empty. The representation of an empty element is either a start-tag immediately followed by an end-tag, or an empty-element tag. [Definition:] An empty-element tag takes a special form:
| Tags for Empty Elements | |||||
|
Empty-element tags MAY be used for any element which has no content, whether or not it is declared using the keyword EMPTY. ·For interoperability·, the empty-element tag SHOULD be used, and SHOULD only be used, for elements which are declared EMPTY.
Examples of empty elements:
<IMG align="left" src="http://www.w3.org/Icons/WWW/w3c_home" /> <br></br> <br/>
3.2 Element Type DeclarationsThe ·element· structure of an ·XML document· MAY, for ·validation· purposes, be constrained using element type and attribute-list declarations. An element type declaration constrains the element's ·content·.
Element type declarations often constrain which element types can appear as ·children· of the element. At user option, an XML processor MAY issue a warning when a declaration mentions an element type for which no declaration is provided, but this is not an error.
[Definition:] An element type declaration takes the form:
| Element Type Declaration | |||||||||
|
where the Name gives the element type being declared.
Validity constraint: Unique Element Type Declaration
An element type MUST NOT be declared more than once.
Examples of element type declarations:
<!ELEMENT br EMPTY> <!ELEMENT p (#PCDATA|emph)* > <!ELEMENT %name.para; %content.para; > <!ELEMENT container ANY>
[Definition:] An element ·type· has element content when elements of that type MUST contain only ·child· elements (no character data), optionally separated by white space (characters matching the nonterminal S). [Definition:] In this case, the constraint includes a content model, a simple grammar governing the allowed types of the child elements and the order in which they are allowed to appear. The grammar is built on content particles (cps), which consist of names, choice lists of content particles, or sequence lists of content particles:
| Element-content Models | ||||||||||||||||||
|
where each Name is the type of an element which
MAY appear as a ·child·. Any content
particle in a choice list MAY appear in the ·element
content· at the location where the choice list appears in the grammar;
content particles occurring in a sequence list MUST each appear in the ·element content· in the order given in the list.
The optional character following a name or list governs whether the element
or the content particles in the list may occur one or more (+),
zero or more (*), or zero or one times (?). The
absence of such an operator means that the element or content particle MUST
appear exactly once. This syntax and meaning are identical to those used in
the productions in this specification.
The content of an element matches a content model if and only if it is possible to trace out a path through the content model, obeying the sequence, choice, and repetition operators and matching each element in the content against an element type in the content model. ·For compatibility·, it is an error if the content model allows an element to match more than one occurrence of an element type in the content model. For more information, see E Deterministic Content Models.
Validity constraint: Proper Group/PE Nesting
Parameter-entity ·replacement text· MUST be properly nested with parenthesized groups. That is to say, if either of the opening or closing parentheses in a choice, seq, or Mixed construct is contained in the replacement text for a ·parameter entity·, both MUST be contained in the same replacement text.
·For interoperability·, if a parameter-entity reference
appears in a choice, seq, or Mixed construct, its replacement text SHOULD contain at
least one non-blank character, and neither the first nor last non-blank character
of the replacement text SHOULD be a connector (| or ,).
Examples of element-content models:
<!ELEMENT spec (front, body, back?)> <!ELEMENT div1 (head, (p | list | note)*, div2*)> <!ELEMENT dictionary-body (%div.mix; | %dict.mix;)*>
[Definition:] An element ·type· has mixed content when elements of that type MAY contain character data, optionally interspersed with ·child· elements. In this case, the types of the child elements MAY be constrained, but not their order or their number of occurrences:
| Mixed-content Declaration | ||||||||||||||
|
where the Names give the types of elements that may appear as children. The keyword #PCDATA derives historically from the term "parsed character data."
Validity constraint: No Duplicate Types
The same name MUST NOT appear more than once in a single mixed-content declaration.
Examples of mixed content declarations:
<!ELEMENT p (#PCDATA|a|ul|b|i|em)*> <!ELEMENT p (#PCDATA | %font; | %phrase; | %special; | %form;)* > <!ELEMENT b (#PCDATA)>
3.3 Attribute-List Declarations·Attributes· are used to associate name-value pairs with ·elements·. Attribute specifications MUST NOT appear outside of ·start-tags· and ·empty-element tags·; thus, the productions used to recognize them appear in 3.1 Start-Tags, End-Tags, and Empty-Element Tags. Attribute-list declarations MAY be used:
[Definition:] Attribute-list declarations specify the name, data type, and default value (if any) of each attribute associated with a given element type:
| Attribute-list Declaration | ||||||||
|
The Name in the AttlistDecl rule is the type of an element. At user option, an XML processor MAY issue a warning if attributes are declared for an element type not itself declared, but this is not an error. The Name in the AttDef rule is the name of the attribute.
When more than one AttlistDecl is provided for a given element type, the contents of all those provided are merged. When more than one definition is provided for the same attribute of a given element type, the first declaration is binding and later declarations are ignored. ·For interoperability,· writers of DTDs MAY choose to provide at most one attribute-list declaration for a given element type, at most one attribute definition for a given attribute name in an attribute-list declaration, and at least one attribute definition in each attribute-list declaration. For interoperability, an XML processor MAY at user option issue a warning when more than one attribute-list declaration is provided for a given element type, or more than one attribute definition is provided for a given attribute, but this is not an error.
XML attribute types are of three kinds: a string type, a set of tokenized types, and enumerated types. The string type may take any literal string as a value; the tokenized types have varying lexical and semantic constraints. The validity constraints noted in the grammar are applied after the attribute value has been normalized as described in 3.3.3 Attribute-Value Normalization.
| Attribute Types | |||||||||||||||||||||||||||||||||||||||||||||||||||||
|
Values of type ID MUST match the Name production. A name MUST NOT appear more than once in an XML document as a value of this type; i.e., ID values MUST uniquely identify the elements which bear them.
Validity constraint: One ID per Element Type
An element type MUST NOT have more than one ID attribute specified.
Validity constraint: ID Attribute Default
An ID attribute MUST have a declared default of #IMPLIED or #REQUIRED.
Values of type IDREF MUST match the Name production, and values of type IDREFS MUST match Names; each Name MUST match the value of an ID attribute on some element in the XML document; i.e. IDREF values MUST match the value of some ID attribute.
Validity constraint: Entity Name
Values of type ENTITY MUST match the Name production, values of type ENTITIES MUST match Names; each Name MUST match the name of an ·unparsed entity· declared in the ·DTD·.
Validity constraint: Name Token
Values of type NMTOKEN MUST match the Nmtoken production; values of type NMTOKENS MUST match Nmtokens.
[Definition:] Enumerated attributes MUST take one of a list of values provided in the declaration. There are two kinds of enumerated types:
| Enumerated Attribute Types | ||||||||||||||||||||||||
|
A NOTATION attribute identifies a ·notation·, declared in the DTD with associated system and/or public identifiers, to be used in interpreting the element to which the attribute is attached.
Validity constraint: Notation Attributes
Values of this type MUST match one of the notation names included in the declaration; all notation names in the declaration MUST be declared.
Validity constraint: One Notation Per Element Type
An element type MUST NOT have more than one NOTATION attribute specified.
Validity constraint: No Notation on Empty Element
·For compatibility·, an attribute of type NOTATION MUST NOT be declared on an element declared EMPTY.
Validity constraint: No Duplicate Tokens
The notation names in a single NotationType attribute declaration, as well as the NmTokens in a single Enumeration attribute declaration, MUST all be distinct.
Validity constraint: Enumeration
Values of this type MUST match one of the Nmtoken tokens in the declaration.
·For interoperability,· the same Nmtoken SHOULD NOT occur more than once in the enumerated attribute types of a single element type.
An ·attribute declaration· provides information on whether the attribute's presence is REQUIRED, and if not, how an XML processor is to react if a declared attribute is absent in a document.
| Attribute Defaults | ||||||||||||||||||||||||
|
In an attribute declaration, #REQUIRED means that the attribute MUST always be provided, #IMPLIED that no default value is provided. [Definition:] If the declaration is neither #REQUIRED nor #IMPLIED, then the AttValue value contains the declared default value; the #FIXED keyword states that the attribute MUST always have the default value. When an XML processor encounters an element without a specification for an attribute for which it has read a default value declaration, it MUST report the attribute with the declared default value to the application.
Validity constraint: Required Attribute
If the default declaration is the keyword #REQUIRED, then the attribute MUST be specified for all elements of the type in the attribute-list declaration.
Validity constraint: Attribute Default Value Syntactically Correct
The declared default value MUST meet the syntactic constraints of the declared attribute type.
Note that only the syntactic constraints of the type are required here; other constraints (e.g. that the value be the name of a declared unparsed entity, for an attribute of type ENTITY) may come into play if the declared default value is actually used (an element without a specification for this attribute occurs).Validity constraint: Fixed Attribute Default
If an attribute has a default value declared with the #FIXED keyword, instances of that attribute MUST match the default value.
Examples of attribute-list declarations:
<!ATTLIST termdef
id ID #REQUIRED
name CDATA #IMPLIED>
<!ATTLIST list
type (bullets|ordered|glossary) "ordered">
<!ATTLIST form
method CDATA #FIXED "POST">Before the value of an attribute is passed to the application or checked for validity, the XML processor MUST normalize the attribute value by applying the algorithm below, or by using some other method such that the value passed to the application is the same as that produced by the algorithm.
If the attribute type is not CDATA, then the XML processor MUST further process the normalized attribute value by discarding any leading and trailing space (#x20) characters, and by replacing sequences of space (#x20) characters by a single space (#x20) character.
Note that if the unnormalized attribute value contains a character reference to a white space character other than space (#x20), the normalized value contains the referenced character itself (#xD, #xA or #x9). This contrasts with the case where the unnormalized value contains a white space character (not a reference), which is replaced with a space character (#x20) in the normalized value and also contrasts with the case where the unnormalized value contains an entity reference whose replacement text contains a white space character; being recursively processed, the white space character is replaced with a space character (#x20) in the normalized value.
All attributes for which no declaration has been read SHOULD be treated by a non-validating processor as if declared CDATA.
It is an error if an ·attribute value