Movatterモバイル変換

An elementtype haselement content when elementsof that typeMUST contain onlychildelements (no character data), optionally separated by white space (charactersmatching the nonterminalS).In this case, the constraint includes acontentmodel, a simple grammar governing the allowed types of thechild elements and the order in which they are allowed to appear.The grammar is built on content particles (cps), whichconsist of names, choice lists of content particles, or sequence lists ofcontent particles:

where eachName is the type of an element which&may; appear as achild. Any contentparticle in a choice list &may; appear in theelementcontent at the location where the choice list appears in the grammar;content particles occurring in a sequence listMUST each appear in theelement content in the order given in the list.The optional character following a name or list governs whether the elementor the content particles in the list may occur one or more (+),zero or more (*), or zero or one times (?). Theabsence of such an operator means that the element or content particleMUSTappear exactly once. This syntax and meaning are identical to those used inthe productions in this specification.

The content of an element matches a content model if and only if it ispossible to trace out a path through the content model, obeying the sequence,choice, and repetition operators and matching each element in the contentagainst an element type in the content model.Forcompatibility, it is an error if the content modelallows an element to match more than one occurrence of an element type in thecontent model. For more information, see.

Examples of element-content models:

An elementtypehasmixed content when elements of that type &may; contain characterdata, optionally interspersed withchildelements. In this case, the types of the child elements &may; be constrained,but not their order or their number of occurrences:

where theNames give the types of elements thatmay appear as children. Thekeyword#PCDATA derives historically from the termparsedcharacter data.

Examples of mixed content declarations:

XML attribute types are of three kinds: a string type, a set of tokenizedtypes, and enumerated types. The string type may take any literal string asa value; the tokenized typeshave varying lexical and semantic constraintsare more constrained.The validity constraints noted in the grammar are applied after the attributevalue has been normalized as described in.

Enumerated attributesMUST take one of a list of valuesprovided in the declarationhave a list of allowedvalues in their declaration.TheyMUST take one of those values.There are two kinds of enumerated attribute types:

ANOTATION attribute identifies anotation,declared in the DTD with associated system and/or public identifiers, to beused in interpreting the element to which the attribute is attached.

For interoperability, the sameNmtokenSHOULD NOT occur more than once in the enumeratedattribute types of a single element type.

Anattribute declaration provides informationon whether the attribute's presence isREQUIRED, and if not, how an XML processoris to react if a declared attribute is absent in a document.

In an attribute declaration,#REQUIRED means that the attributeMUST always be provided,#IMPLIED that no default value is provided.Ifthe declaration is neither#REQUIRED nor#IMPLIED, thentheAttValue value contains the declareddefaultvalue; the#FIXED keyword states that the attributeMUST always havethe default value.When an XML processor encountersan elementwithout a specification for an attribute for which it has read a defaultvalue declaration, itMUST report the attribute with the declared defaultvalue to the application.

Examples of attribute-list declarations:

Before the value of an attribute is passed to the application or checkedfor validity, the XML processorMUST normalize the attribute value by applyingthe algorithm below, or by using some other method such that the value passedto the application is the same as that produced by the algorithm.

If the attribute type is not CDATA, then the XML processorMUST furtherprocess the normalized attribute value by discarding any leading and trailingspace (#x20) characters, and by replacing sequences of space (#x20) charactersby a single space (#x20) character.

Note that if the unnormalized attribute value contains a character referenceto a white space character other than space (#x20), the normalized value containsthe referenced character itself (#xD, #xA or #x9). This contrasts with thecase where the unnormalized value contains a white space character (not areference), which is replaced with a space character (#x20) in the normalizedvalue and also contrasts with the case where the unnormalized value containsan entity reference whose replacement text contains a white space character;being recursively processed, the white space character is replaced with aspace character (#x20) in the normalized value.

All attributes for which no declaration has been readSHOULD be treatedby a non-validating processor as if declaredCDATA.

Itis an error if anattributevalue contains areference to anentity for which no declaration has been read.

Following are examples of attribute normalization. Given the followingdeclarations:

If theentity definition is anEntityValue, the definedentity is called aninternal entity. There is no separate physicalstorage object, and the content of the entity is given in the declaration.Note that some processing of entity and character references in theliteral entity value may be required to producethe correctreplacement text: see.

An internal entity is aparsed entity.

Example of an internal entity declaration:

If the entity is not internal,it is anexternal entity, declared as follows:

If theNDataDecl is present, this is a generalunparsed entity; otherwise it is a parsed entity.

TheSystemLiteral is called the entity'ssystemidentifier. It is meant to beconverted to a URI reference(as defined in, updated by),as part of theprocess of dereferencing it to obtain input for the XML processor to construct theentity's replacement text. It is an error for a fragment identifier(beginning with a# character) to be part of a system identifier.Unless otherwise provided by information outside the scope of this specification(e.g. a special XML element type defined by a particular DTD, or a processinginstruction defined by a particular application specification), relative URIsare relative to the location of the resource within which the entity declarationoccurs. This is defined tobe the external entity containing the '<' which starts the declaration, at thepoint when it is parsed as a declaration.A URI might thus be relative to thedocumententity, to the entity containing theexternalDTD subset, or to some otherexternal parameterentity. Attempts toretrieve the resource identified by a URI &may; be redirected at the parserlevel (for example, in an entity resolver) or below (at the protocol level,for example, via an HTTPLocation: header). In the absence of additionalinformation outside the scope of this specification within the resource,the base URI of a resource is always the URI of the actual resource returned.In other words, it is the URI of the resource retrieved after all redirectionhas occurred.

Systemidentifiers (and other XML strings meant to be used as URI references) &may; containcharacters that, according to and,must be escaped before a URI can be used to retrieve the referenced resource. Thecharacters to be escaped are the control characters #x0 to #x1F and #x7F (most ofwhich cannot appear in XML), space #x20, the delimiters '<' #x3C, '>' #x3E and'"' #x22, theunwise characters '{' #x7B, '}' #x7D, '|' #x7C, '\' #x5C, '^' #x5E and'`' #x60, as well as all characters above #x7F. Since escaping is not always a fullyreversible process, itMUST be performed only when absolutely necessary and as lateas possible in a processing chain. In particular, neither the process of convertinga relative URI to an absolute one nor the process of passing a URI reference to aprocess or software component responsible for dereferencing itSHOULD trigger escaping.When escaping does occur, itMUST be performed as follows:

In addition to a systemidentifier, an external identifier &may; include apublic identifier.An XML processor attempting to retrieve the entity's content &may; useany combination ofthe public and system identifiers as well as additional information outside thescope of this specification to try to generate an alternative URI reference.If the processor is unable to do so, itMUST use the URIreference specified in the system literal. Before a match is attempted,all strings of white space in the public identifierMUST be normalized tosingle space characters (#x20), and leading and trailing white spaceMUSTbe removed.

Examples of external entity declarations:

External parsed entitiesSHOULD each begin with atext declaration.

The text declarationMUST be provided literally, not by referenceto a parsed entity. The text declarationMUST NOT appear at anyposition other than the beginning of an external parsed entity. The text declarationin an external parsed entity is not considered part of itsreplacement text.

The document entity is well-formed if it matches the production labeleddocument. An external general parsed entity is well-formedif it matches the production labeledextParsedEnt. Allexternal parameter entities are well-formed by definition.

An internal general parsed entity is well-formed if its replacement textmatches the production labeledcontent. All internalparameter entities are well-formed by definition.

A consequence of well-formedness in generalentities is that the logical and physicalstructures in an XML document are properly nested; nostart-tag,end-tag,empty-element tag,element,comment,processing instruction,characterreference, orentity referencecan begin in one entity and end in another.

Each external parsed entity in an XML document &may; use a different encodingfor its characters. All XML processorsMUST be able to read entities in boththe UTF-8 and UTF-16 encodings. The termsUTF-8andUTF-16 in this specification do not apply to characterencodings with any other labels, even if the encodings or labels are verysimilar to UTF-8 or UTF-16.

Entities encoded in UTF-16MUST and entitiesencoded in UTF-8 &MAY; begin with the Byte Order Mark described inISO/IEC 10646 or Unicode(the ZERO WIDTH NO-BREAK SPACE character, #xFEFF). This is an encoding signature,not part of either the markup or the character data of the XML document. XMLprocessorsMUST be able to use this character to differentiate between UTF-8and UTF-16 encoded documents.

Although an XML processor is required to read only entities in the UTF-8and UTF-16 encodings, it is recognized that other encodings are used aroundthe world, and it may be desired for XML processors to read entities thatuse them. Inthe absence of external character encoding information (such as MIME headers),parsed entities which are stored in an encoding other than UTF-8 or UTF-16MUST begin with a text declaration (see) containingan encoding declaration:

In thedocument entity, the encodingdeclaration is part of theXML declaration.TheEncName is the name of the encoding used.

In an encoding declaration, the valuesUTF-8,UTF-16,ISO-10646-UCS-2, andISO-10646-UCS-4SHOULD be usedfor the various encodings and transformations of Unicode / ISO/IEC 10646,the valuesISO-8859-1,ISO-8859-2,...ISO-8859-n (wherenis the part number)SHOULD be used for the parts of ISO 8859, andthe valuesISO-2022-JP,Shift_JIS,andEUC-JPSHOULD be used for the various encodedforms of JIS X-0208-1997. ItisRECOMMENDED that character encodings registered (ascharsets)with the Internet Assigned Numbers Authority,other than those just listed, be referred to using their registered names;other encodingsSHOULD use names starting with anx- prefix.XML processorsSHOULD match character encoding names in a case-insensitiveway andSHOULD either interpret an IANA-registered name as the encoding registeredat IANA for that name or treat it as unknown (processors are, of course, notrequired to support all IANA-registered encodings).

In the absence of information provided by an external transport protocol(e.g. HTTP or MIME), it is afatal error foran entity including an encoding declaration to be presented to the XML processorin an encoding other than that named in the declaration, or for an entity whichbegins with neither a Byte Order Marknor an encoding declaration to use an encoding other than UTF-8. Note thatsince ASCII is a subset of UTF-8, ordinary ASCII entities do not strictlyneed an encoding declaration.

It is afatal error for aTextDecl to occur otherthan at the beginning of an external entity.

It is afatal error when an XML processorencounters an entity with an encoding that it is unable to process. Itis afatal error if an XML entity is determined (via default, encoding declaration,or higher-level protocol) to be in a certain encoding but contains bytesequences that are not legal in that encoding. Specifically, it is afatal error if an entity encoded in UTF-8 contains any irregular code unit sequences,as defined in Unicode. Unless an encodingis determined by a higher-level protocol, it is also afatal error if an XML entitycontains no encoding declaration and its content is not legal UTF-8 or UTF-16.

Examples of text declarations containing encoding declarations:

Each entity, including thedocument entity,can be separatelydeclared as XML 1.0 or XML 1.1. The version declaration appearingin the document entity determines the version of the document as awhole. An XML 1.1 document may invoke XML 1.0 external entities, sothat otherwise duplicated versions of external entities,particularly DTD external subsets, need not be maintained. However,in such a case the rules of XML 1.1 are applied to the entiredocument.

If an entity (including the document entity) is not labeledwith a version number, it is treated as if labeled as version1.0.

Outside the DTD, the% character has no special significance;thus, what would be parameter entity references in the DTD are not recognizedas markup incontent. Similarly, the names of unparsedentities are not recognized except when they appear in the value of an appropriatelydeclared attribute.

An entity isincludedwhen itsreplacement text is retrievedand processed, in place of the reference itself, as though it were part ofthe document at the location the reference was recognized. The replacementtext &may; contain bothcharacter dataand (except for parameter entities)markup,whichMUST be recognized in the usual way. (The stringAT&T;expands toAT&T; and the remaining ampersandis not recognized as an entity-reference delimiter.) A character referenceisincluded when the indicated character is processed in placeof the reference itself.

When an XML processor recognizes a reference to a parsed entity, in ordertovalidate the document, the processorMUSTinclude its replacement text. Ifthe entity is external, and the processor is not attempting to validate theXML document, the processor &MAY;, but neednot, include the entity's replacement text. If a non-validating processordoes not include the replacement text, itMUST inform the application thatit recognized, but did not read, the entity.

This rule is based on the recognition that the automatic inclusion providedby the SGML and XML entity mechanism, primarily designed to support modularityin authoring, is not necessarily appropriate for other applications, in particulardocument browsing. Browsers, for example, when encountering an external parsedentity reference, might choose to provide a visual indication of the entity'spresence and retrieve it for display only on demand.

The following are forbidden, and constitutefatalerrors:

When anentity reference appears inan attribute value, or a parameter entity reference appears in a literal entityvalue, itsreplacement textMUST be processedin place of the reference itself as though it were part of the document atthe location the reference was recognized, except that a single or doublequote character in the replacement textMUST always be treated as a normal datacharacter andMUST NOT terminate the literal. For example, this is well-formed:

while this is not:

When the name of anunparsed entityappears as a token in the value of an attribute of declared typeENTITYorENTITIES, a validating processorMUST inform the application ofthesystem andpublic(if any) identifiers for both the entity and its associatednotation.

When a general entity reference appears in theEntityValuein an entity declaration, itMUST be bypassed and left as is.

Just as with external parsed entities, parameter entities need only beincluded if validating. When a parameter-entityreference is recognized in the DTD and included, itsreplacementtextMUST be enlarged by the attachment of one leading and one followingspace (#x20) character; the intent is to constrain the replacement text ofparameter entities to contain an integral number of grammatical tokens inthe DTD. ThisbehaviorMUST NOT apply to parameter entity references within entity values;these are described in.

It is anerror for a reference toan unparsed entity to appear in theEntityValue in anentity declaration.