W3C XML Schema Working Group"> XML Schema: Structures"> XML Schemas: Datatypes"> ]>
XML Schema Part 1: Structures &XSP1.version; &WD-XSP1;-&iso.doc.date; W3C Working Draft &draft.day; &draft.month; &draft.year; The following SHOULD be in the publoc, but the DTD doesn't currently allow it: the stylesheet fakes it.

(in XML (with its own DTD, XSL stylesheet (July XSL WD version) and IE5 stylesheet (XSL as supported by version 5 of Microsoft's Internet Explorer)) and HTML, with separate provision of the schema and DTD for schemas described herein.

&XSP1.base;/&WD-XSP1;/ http://www.w3.org/TR/xmlschema-1/ http://www.w3.org/1999/05/06-xmlschema-1/ Henry S. Thompson University of Edinburgh ht@cogsci.ed.ac.uk David Beech Oracle dbeech@us.oracle.com Murray Maloney Commerce One murray@muzmo.com Noah Mendelsohn Lotus noah_mendelsohn@lotus.com

This is a W3C Working Draft for review by members of the W3C and other interested parties in the general public.

It has been reviewed by the XML Schema Working Group and the Working Group has agreed to its publication. Note that not that all sections of the draft represent the current consensus of the WG. Different sections of the specification may well command different levels of consensus in the WG. Public comments on this draft will be instrumental in the WG's deliberations.

Please review and send comments to www-xml-schema-comments@w3.org (archive).

This draft incorporates a substantial change to the concrete syntax from the previous public working draft, intended to simplify it and make it easier to use (the full text of the proposal from the working group's task force , along with a cover note containing a discussion of alternatives considered and outstanding issues , are available as background).

Three major components of this document are marked below as out-of-date and/or under construction: major efforts by task forces from within the WG are underway with respect to these, and their reports are linked from this draft. We felt it was important to present this work to the public, in keeping with our obligation to produce drafts for public inspection and comment on a regular basis, despite the "Under Construction" signs posted below. It is our intention henceforth to publish interim working drafts with greater frequency, both to keep interested parties informed of our progress, and to emphasize the "work in progress" nature of these drafts.

Sections which are not the status quo, that is on which the working group has not yet reached consensus, are marked with an asterisk (*) at the end of the section title. But please note that all the facilities described herein are in a preliminary state of design. The Working Group anticipates substantial changes, both in the mechanisms described herein, and in additional functions yet to be described. The present version should not be implemented except as a check on the design and to allow experimentation with alternative designs. The Schema WG will not allow early implementation to constrain its ability to make changes to this specification prior to final release.

A list of current W3C working drafts can be found at http://www.w3.org/TR. They may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use W3C Working Drafts as reference material or to cite them as other than "work in progress".

XML Schema: Structures is part 1 of a two-part draft of the specification for the XML Schema definition language. This document proposes facilities for describing the structure and constraining the contents of XML 1.0 documents. The schema language, which is itself represented in XML 1.0, provides a superset of the capabilities found in XML 1.0 document type definitions (DTDs).

Boston, Mountain View, Toronto, et al.: World-Wide Web Consortium, XML Working Group, 1999.

Created in electronic form using XML.

English Extended Backus-Naur Form (formal grammar) Extensible Markup Language (XML) 1999-09-02: HST: Marked non-status-quo sections as such. 1999-09-01: HST: incorporated Section 2 examples from 'Simple', modified to include some attributes. Massaged explanatory text. 1999-08-22: HST: incorporated 'Simple' section 3 changes and started to smooth over the joints. 1999-07-18: DB: updated definition of "Schema" following WG and IG email discussion. Changed "Schemata" to "Schemas" except where directly quoted from Requirements doc. Clarified in 2.5 that elements and attributes have separate symbol spaces (public comment). Fixed assorted typos. 1999-06-23: HST: pushed & down to lowest level, fixed incoherent validity definition in 6.2.3.7 to agree with the note which follows. Wrapped validation text from 3.4 in appropriately named div4's. 1999-06-20: HST: stripped out validation 1999-05-03: MCM: Updated schema and DTD. Package and test. 1999-05-03 Integration of final editors' concerns for WD1. Includes HT work on constraints. 1999-05-02 NRM General cleanup of first few chapters. Remove chapter 4 redundancy (tuple discussion) with new validity rules. 1999-05-02: HST: still chipping away at validity. Redefined the XSDL/XDTL entities. 19940502: MCM: mostly annotating the schema. Also moved info about abstract grammar into Chapter 2. Chapter 3 now starts right into defining a schema. Edited text entities to make them easier to manage. 19940501: HST: various 1999-04-30: NRM : revisions to chapter 4 1999-04-28: DB (pp HST) : promised edits for improved consistency and definition of 'schema'; suggested modifications to 3.4.9/10 and 3.5 1999-04-39: HST : integrated DB's edits, completely rewrote 6.1, replaced virtually all <B> with correct <...ref> 1999-04-28: DB (pp HST) : promised edits for improved consistency and definition of 'schema'; suggested modifications to 3.4.9/10 and 3.5 1999-04-23: HST : Got all productions sorted using 'nt' and correct IDs. 1999-04-21 : HST : Added lots of IDs and constraint heads: Validates w/o error 1999-04-21 : HST : Converted with no content changes to speak of from MCM-XSDL-19990416.html. This version has only ID/IDREF related errors left.
Introduction

This document sets out the structural part (&XSP1;) of the XML Schema definition language.

Chapter 2 presents a for &XSP1;, including an introduction to schema constraints, types, schema composition, and symbol spaces. The abstract and concrete syntax of &XSP1; are introduced, along with other terminology used throughout the specification.

Chapter 3 reconstructs the core functionality of XML 1.0, plus a number of extensions, in line with our stated requirements . This chapter discusses the declaration and use of datatypes, archetypes, element, content models, attributes, attribute groups, model groups, refinement, entities and notations.

Chapter 4 presents , including the validation of namespace qualified instance documents, import, inclusion and export of declarations and definitions, schema paths, access to schemas, and related rules for schema-based validity.

Chapter 5 is a placeholder for , which will eventually provide a standardized means for including documentation in the definition of a schema.

Chapter 6 discusses , including the rules by which instance documents are validated, and responsibilities of schema-aware processors.

The normative addenda include a and a , which is an XML Schema schema for &XSP1;, a [not yet written] and . Non-normative appendixes include a and .

Documentation Conventions

This Working Draft document was produced using an DTD and an stylesheet.

The following highlighting is used to present technical material in this document:

A term is something we use a lot.

Sample Abstract Syntax Production left right1 right2

A non-normative example illustrating use of the schema language, or a related instance.

<schema name='http://www.muzmo.com/XMLSchema/1.0/mySchema' >

And an explanation of the example.

The following highlighting is used for non-normative commentary in this document:

A recorded issue.

Notes shared among the editorial team.

General comments directed to all readers.

Purpose

The purpose of &XSP1; is to provide an inventory of XML markup constructs with which to write schemas.

The purpose of an &XSP1; schema is to define and describe a class of XML documents by using these constructs to constrain and document the meaning, usage and relationships of their constituent parts: datatypes, elements and their content, attributes and their values, entities and their contents and notations. Schema constructs may also provide for the specification of additional information such as default values. Schemas are intended to document their own meaning, usage, and function through a common documentation vocabulary. Thus, &XSP1; can be used to define, describe and catalogue XML vocabularies for classes of XML documents.

Any application that consumes well-formed XML can use the &XSP1; formalism to express syntactic, structural and value constraints applicable to its document instances. The &XSP1; formalism will allow a useful level of constraint checking to be described and validated for a wide spectrum of XML applications. However, the language defined by this specification does not attempt to provide all the facilities that might be needed by any application. Some applications may require constraint capabilities not expressible in this language, and so may need to perform their own additional validations.

Relationship To Other Work

The definition of &XSP1; is a part of the W3C XML Activity. It is in various ways related to other ongoing parts of that Activity and other W3C WGs

&XSP1; has a dependency on the data typing mechanisms defined in its companion , published simultaneously with this recommendation.

&XSP1; has not yet identified requirements or dependencies.

&XSP1; has a requirement to support modularization of HTML.

See http://www.w3.org/XML/Group/1999/03/xml-schema-i18n-notes

&XSP1; has not yet documented requirements or dependencies.

Need to reference Cambridge Communique as soon as it's published.

&XSP1; has a requirement to support accessibility.

&XSP1; has significant dependencies on .

&XSP1; defines its own Information Set Contributions.

&XSP1; will have requirements for subsequent Information Set Working Drafts.

&XSP1; has not yet identified requirements or dependencies.

&XSP1; must interoperate with XML 1.0 and subsequent revisions.

&XSP1; has a requirement to support dimensions and aggregate datatypes.

Terminology

The terminology used to describe &XSP1; is defined in the body of this specification. The terms defined in the following list are used in building those definitions and in describing the actions of &XSP1; processors:

Conforming documents and processors are permitted to but need not behave as described.

Conforming documents and processors are required to behave as described; otherwise they are in error.

A violation of the rules of this specification; results are undefined. Conforming software may detect and report an error and may recover from it.

An error which a conforming processor must detect and report to the application.

(Of strings or names:) Two strings or names being compared must be character for character the same.

(Of URIs or schemaNames:) identical, according to the rules for identity in .

Conceptual Framework

This specification uses a number of terms that are common to many of the fields of endeavor that have influenced the development of XML Schema. Unfortunately, it is often the case that these terms do not have the same definitions in all of those fields. This section attempts to provide definitions of terms as they are used to describe the conceptual framework, and the remainder of the specification.

Kinds of XML Documents

Since XML schemas are themselves specified as XML documents or elements within documents, it is useful to clarify the relationships between certain kinds of XML documents and elements:

An XML element information item which conforms to some schema. See for a discussion of information items: in brief, an element information item is the component of an infoset which corresponds to an element. From it other information items are accessible, including attributes, namespace declaration and content. See and for the means by which an instance identifies the schema(s) to which it conforms. Note we will often speak loosely about an (XML) instance document, but this is just shorthand for element information item associated with the document element of an XML document. Similarly, we will often speak of elements when we mean element information item.

An XML element information item which, along with its descendants, satisfies all the Constraints on Schemas in this specification. An XML Schema establishes a set of rules for constraining the structure and articulating the information set of XML document instances.

Note that it is possible to specify a schema to which schemas themselves must conform, and this is given in . An XML 1.0 DTD to which schemas must conform is also provided in .

Any schema is ipso facto an element information item. It follows that the rules specified herein for validity apply to all of the following kinds of XML element information items:

Elements that are not schemas;

Schemas applicable to documents that are not schemas;

The schema applicable to schemas.

Likewise, rules for schemas in general apply to the particular schema for schemas, which is an instance conforming to itself.

On schemas, constraints and contributions

The specification describes two kinds of constraints on XML documents: well-formedness and validity constraints. Informally, the well-formedness constraints are those imposed by the definition of XML itself (such as the rules for the use of the < and > characters and the rules for proper nesting of elements), while validity constraints are the further constraints on document structure provided by a particular DTD.

Three kinds of normative statements about the impact of &XSP1; components on instances are distinguished in this specification:

Constraints on the form and content of schemas themselves, above and beyond those expressed in ;

Constraints on the form and content of instances, which the instances must satisfy to be schema-valid;

Augmentations to instance information sets which follow as a consequence of schema-validation.

Schema Information Set Contributions are not as new as might at first appear: XML 1.0 validation augments the XML 1.0 information set in similar ways, e.g. by providing values for attributes not present in instances, and by implicitly exploiting type information for normalization or access, e.g. consider the effect of NMTOKENS on attribute whitespace, and the semantics of ID and IDREF. By including Schema Information Set Contributions, we are trying to make explicit something XML 1.0 left implicit.

&XSP1; not only reconstructs the DTD constraints of XML 1.0 using XML instance syntax, it also adds the ability to define new kinds of constraints. For example, although the author of an XML 1.0 DTD may declare an element type as containing character data, elements, or mixed content, there is no mechanism with which to constrain the contents of elements to only character data of a particular form, such as only integers in a specified range.

This specification supports the expression of just such constraints by including in the mechanism for the declaration of elements the option of specifying that its contents must consist of a valid string expression of a particular datatype. A number of other mechanisms are added which improve the expressive power, usability and maintainability of schemas as a means to defining the structure of XML documents.

Schemas, Types and Elements

The purpose of a schema is to identify a set of components for use in XML documents and to provide the rules for their correct combination.

The schema language is itself a set of elements and attributes. We will describe these, and show how they are used. But first, a quick example of an XML document.

Alice Smith 123 Maple Street Mill Valley CA 90952 1999-05-25 Get these things to me in a hurry, my lawn is going wild! Lawnmower, model BUZZ-1 1 148.95 Please confirm this is the electric model Baby Monitor, model SNOOZE-2 1 39.98 ]]>

The purchase order consists of a main element with several subordinate elements. Most of the subelements have simple atomic types such as string or date, drawn from the repertoire of built-in datatypes defined in , but some are complex. We use the archetype element when declaring elements which allow elements in their content and/or may carry attributes. For example, we can define an archetype called Address as follows:

]]>

The consequence of this definition is that an element whose type is declared to be Address must consist of five elements and may have one attribute. Though each has a distinct name, four of the elements and the attribute will simply contain a string in a document instance while one will contain a number.

If we're going to use the same element in a number of places, we can declare it once and refer to it by name elsewhere:

]]>

This declaration restricts the comment element to text content and no attributes.

We can define a PurchaseOrderType for our PurchaseOrder element, referring to the definitions of Address and comment as above, as:

]]>

The shipDate element daughter of PurchaseOrderType is declared above as having an atomic type, as in the Address example above. The comment daughter is declared by reference to a global element declaration. Similarly, the shipTo and Items daughters are declared as having complex types which must be defined elsewhere in the current schema. The comment daughter and the orderDate attribute are optional, the others are obligatory.

Further integration of the concrete syntax for type definitions is desireable, e.g. by using 'type' for both archetypes and and datatypes, but the details of a consistent and clear way to do this have not yet been agreed.

Since an element declaration's type can identify either a datatype or an archetype, and there are separate symbol spaces for these two, the possibility of ambiguity arises. This is resolved in favour of the archetype, e.g. even if a datatype called Address existed (either builtin or user-defined), the above declaration for shipTo would refer to the user-defined archetype of that name.

The separation of the datatype and archetype name symbol spaces is primarily motivated by the decision to allow unqualified reference to the ab initio and built-in datatypes. Should this decision be reversed, as was suggested in the report of the simplification Task Force, then the unification of the two symbol spaces could proceed with minimal negative impact. The potential for error which arises from unexpected shadowing of an old datatype by a new archetype would be removed.

A definition creates a new archetype or datatype; a declaration enables the appearance in a document instance of an element or attribute with a specific name and type. In the schema, we see both the definition of several types, and also several elements and attributes declared as usages of these types. For example, Address is defined to be an archetype, while within the definition of Address we see five declarations of elements and one attribute declaration. These declarations are not themselves types, but rather an association between a name and constraints which govern the appearance of that name in documents governed by the containing schema.

In the case of attribute declarations, the constraints are on the allowed value, always by reference to a datatype:

]]>

In the case of element declarations, the constraints are on the allowed content and attributes, by reference to an archetype or a datatype (in which case no attributes are allowed):

]]>

Because Address is defined in the schema to have certain elements as its content and to allow a certain attribute, any shipTo element appearing in an instance must include those elements and may have that attribute, while any comment element may not have any attributes, but any text content.

As well as naming a datatype or archetype in an attribute or element declaration, we can embed the type definition immediately within the element declaration:

0 ]]>

Here not only is the archetype of the Item element given in line, but also the datatype referenced by its quantity daughter (the built-in integer datatype) is also qualified inline by adding a subrange constraint.

Taken together the examples above constitute a complete schema for the initial PurchaseOrder example instance. They are drawn together in a single complete schema in .

Schemas and their component parts

The next chapter sets out the &XSP1; approach to schemas and formal definitions of their component parts. Here we informally summarize the key constructs used in defining schemas. A 'Yes' in the 'Name apears in instances?' column indicates that the name will appear in instances -- other names are for schema use only.

&XSP1; Feature Purpose Named? Name appears in instances?
A wrapper element containing all the definitions and declarations comprising a schema. Yes No
An atomic type (content constraint), such as 'integer', that applies to character data in an instance document, whether it appears as an attribute value or the contents of an element. The mechanisms for defining datatypes are set out elsewhere, in &XSP2;. Yes No
A complete set of constraints for elements in instance documents, applying to both contents and attributes. Yes No
An association between a name for an element and a type. An element declaration for 'A' is comparable to a DTD declaration <!ELEMENT A .....>. Yes (local or global) Yes
An association between a name for an attribute and a datatype, together with occurrence constraints such as 'required' or 'default'. The association is local to its surrounding archetype. Yes (local) Yes
Content type Either a datatype or a content model. A content type applies to the contents of elements in an instance document (but not their attribute values). It provides a unifying abstraction for the constraints which apply to the contents of elements, but introduces no additional features. No No
A constraint that applies to the contents of elements in an instance document. Content models do not include attribute declarations. No No
Components for constructing content models which allow only element content. Includes facilities for grouping and sequencing, as well as for declaration of and reference to elements. No (but see below) No
An association between a name and a reusable collection of attribute declarations. Yes No
Model groups are part of the content model building block abstraction, but are unnamed and cannot be referenced for reuse. A named model group is an association between a name and a model group, allowing for reuse. Yes No
One archetype may be defined as refining one or more other archetypes, acquiring content type and/or attributes therefrom. Yes No
Extends the current schema with definitions and/or declarations from elsewhere, retaining the association with their origin. No No
Integrates definitions and/or declarations from elsewhere into the schema being defined, as if they had been defined locally. No No
Names and Symbol Spaces

As indicated in the third column of the tables above, most of the components listed have names, which provide for references within the schema, and sometimes from one schema to another. For example, an attribute declaration can refer to a named datatype, such as 'integer'. A content model can refer to an element, and so on.

If all such names were assigned from the same 'pool', then it would be impossible to have e.g. a datatype named 'integer' and an element with the name 'integer' in the same schema. Accordingly we introduce the idea of a symbol space (avoiding 'name space' to avoid confusion with 'Namespaces in XML' ).

There is a single distinct symbol space within a given schema for each of the abstractions named above other than 'Attribute' and 'element': within a given symbol space, names are unique, but the same name may appear in more than one symbol space without conflict. In particular note that the same name can refer to both a type and an element, without conflict or necessary relation between the two.

Attributes and local element declarations are special, in that every archetype defines its own attribute symbol space and local element symbol space, which are distinct from each other. In addition, top-level elements (whose declarations are not contained within an archetype definition) reside in their own symbol space.

Abstract and Concrete Syntax

&XSP1; is presented here primarily in the form of an abstract syntax, which provides a formal specification of the information provided for each declaration and definition in the schema language. The abstract syntax is presented using a simplified BNF. Defined terms are to the left. Their components are to the right, with a small amount of meta-syntax: ()s for grouping, | to separate alternatives, ? for optionality, * and + for iteration. Terms in italics are primitives, not expanded here, either because they are defined elsewhere (e.g. URI, defined by ) or because they can only be grounded once a concrete syntax is decided on (e.g. choice).

An abstract syntax production prefixed with a number in brackets (e.g. [3]) is normative; other abstract syntax is either for purposes of explanation, or is a duplicate (for convenience) of a normative definition to be found elsewhere.

The abstract syntax illustrates the expressive power of the language, and the relationships among its component parts. The abstract syntax can be used to evaluate the expressive power of &XSP1;, but not its look and feel. In particular, please note that neither ordering within or between productions or choice of names is significant, and that any particular concrete syntax is not constrained by these.

The concrete syntax of &XSP1;, the exact element and attribute names used in a schema, are a key feature of its proposed design. The concrete syntax is the form in which the schema language is used by schema authors. Though its elements and attributes are often different from the terms of the abstract syntax BNF, the features and expressive power of the two are congruent. The concrete syntax profoundly affects the convenience and usability of the schema language.

We include a preliminary concrete syntax in this draft, via examples, paradigms and in and . Unlike the previous version, in which the intention was to stay quite close to the abstract syntax, in this version we have begun to take convenience and clarity into account.

Schema Definitions and Declarations

The principal purpose of &XSP1; is to provide a means for defining schemas that constrain the contents of instances and augment the information sets thereof.

The Schema

A schema contains some preamble information and a set of definitions and declarations.

Schema top level schema preamble dds* dds datatypeDefn | archetypeDefn | elementDecl | attrGroupDefn | modelGroupDefn | notationDecl | entityDecl preamble xmlSchemaRef targetNamespace schemaVersion model export? import? include? xmlSchemaRef URI targetNamespace URI schemaVersion string-value model open | refinable | closed

preamble consists of an xmlSchemaRef specifying the URI for &XSP1;; the targetNamespace specifying the URI of the namespace which this schema is about; and a schemaVersion specification for private version documentation purposes and version management.

See for discussion of schemas, instances and namespaces.

The whole matter of instance/schema connections is still under discussion: the WG has not reached consensus in this area. The referenced section does give some indication of where our thinking in this area is going. <!DOCTYPE schema PUBLIC '-//W3C//DTD XML Schema Version 1.0//EN' SYSTEM '&XSP1.URI;.dtd' > <schema targetNS='http://purl.org/metadata/dublin_core' version='M.n' xmlns='&XSP1.base;'> ... </schema>

Note that the abstract syntax xmlSchemaRef is realised via a default namespace declaration in the concrete syntax.

Although the schema above is a complete XML document, schema need not be the document element, but can appear within other documents. Indeed there is no requirement that a schema be derived from a (text) document at all: it could be built 'by hand' via e.g. a DOM-conformant API.

The schema's model property is discussed in . The schema's export, import and include properties are discussed in .

The schema's declarations and definitions, discussed in detail in , provide for the creation of new schema components:

Summary of Definitions and Declarations datatypeDefn NCName datatypeSpec archetypeDefn NCName archetypeSpec elementDecl NCName elementSpec modelGroupDefn NCName modelGroupSpec attrGroupDefn NCName attrGroupSpec entityDecl NCName entitySpec notationDecl NCName notationSpec

The following illustrates the basic model for declaring or defining all &XSP1; components:

<datatype name='myDatatype'> ... </datatype> <archetype name='myType'> ... </archetype> <element name='myElement'> ... </element> <attrGroup name='myAttrGroup'> ... </attrGroup> <modelGroup name='myModelGroup'> ... </modelGroup> <notation name='myNotation' ... /> <textEntity name='myTextEntity'> ... </textEntity> <externalEntity name='myExternalEntity' ... /> <unparsedEntity name='myUnparsedEntity' ... /> </schema>

When creating a component, we establish an association between its name and the specification for that component. Each new component therefore creates a new entry in the symbol space for that kind of component.

The Constraint on Schemas obtains.

This draft does not deal with the requirement "for addressing the evolution of schemata" (see ).

The Document and its Root

We have not so far seen any need to reconstruct the XML 1.0 notion of root. For the connection from document instances to schemas, see and .

References to Schema Constructs

Uniform means are provided for reference to a broad variety of schema constructs, both within a single schema and to features imported () from external schemas. The name used to reference any component of &XSP1; from within a schema consists of an NCName and an optional schemaRef, a reference to an external schema. In a few cases, some qualification may be added to a reference: this is made clear as the individual reference forms are introduced below.

Example: Component Names and References schemaRef (schemaAbbrev | schemaName) schemaAbbrev NCName schemaName URI typeRef archetypeRef | datatypeRef datatypeRef datatypeName datatypeQual datatypeName NCName schemaRef? archetypeRef typeName archetypeName NCName schemaRef? elementRef elementName elementName NCName schemaRef? attrGroupRef attrGroupName attrGroupQual attrGroupName NCName schemaRef? modelGroupRef modelGroupName modelGroupName NCName schemaRef? entityRef entityName entityName NCName schemaRef? notationRef notationName notationName NCName schemaRef?

The abstract syntax above characterizes the reference mechanisms used in this specification.

<element type='Address'/> <element type='BLOCKQUOTE' schemaAbbrev='XHTML'/> <attribute type='quantity' schemaName='http://www.w3.org/xsl.xsd'/>

The first of these is a local reference, the other two refer to schemas elsewhere. The BLOCKQUOTE example assumes the schemaAbbrev XHTML has been declared for import; the template example similarly assumes that the given (imaginary as of this writing) URL has been declared for import. See for a discussion of importing.

The Constraint on Schemas obtains.

The Constraint on Schemas obtains.

The identify definition wrt schema-validity obtains.

The Constraint on Schemas also obtains.

Types, Elements and Attributes

Like XML 1.0 DTDs, &XSP1; provides facilities for constraining the contents of elements and the values of attributes, and for augmenting the information set of instances, e.g. with defaulted values and type information. We refer hereafter to the combination of schema constraints and information set contributions with the abbreviation SC. Compared to DTDs, &XSP1; provides for a richer set of SCs, and improved capabilities for sharing SCs across sets of elements and attributes.

Datatype Definition

We start with the simple datatypes whose expression in XML documents consists entirely of character data. As in the current draft of &XSP2;, wherever we speak of datatypes in this draft, we shall mean these simple datatypes.

Datatypes datatypeDefn NCName datatypeSpec datatypeSpec [defined by XML Schemas: Datatypes] exportControl? datatypeQual specialize? valueConstraint? specialize facet+ facet is defined by XML Schemas: Datatypes. It might be a range restriction, length constraint, etc. valueConstraint default | fixed datatypeRef datatypeName datatypeQual datatypeName NCName schemaRef? schemaRef (schemaAbbrev | schemaName) schemaAbbrev NCName schemaName URI

&XSP1; incorporates the datatype specification mechanisms defined by in order to express SCs on attribute values and the contents of elements consisting entirely of character data.

The production for datatypeSpec above serves to indicate where this chapter connects with &XSP2;. exportControl is defined in . The concrete syntax displayed below is copied from . Most of the elements are for specifying facets: they are all optional and may appear in any order after the basetype element.

The other productions provide for using datatypes once they have been defined, see below under contentType and attribute.

We assume that it is appropriate to allow for some local specialization of datatypes at the point of use, and provide for that here (specialize).

As explained in , a schemaRef, if included, allows for the referenced definition to be located in some other schema.

0 12pt ]]>

The first attribute example references the definition above it. The second references a datatype pre-defined by &XSP2;. The third references a datatype in an (imaginary) XSL schema and fixes its value.

See previous note on the type definition issue.

The satisfy-dt definition wrt schema-validity obtains.

The Schema Information Set Contribution obtains.

Archetype Definition

Archetype specifications gather together all SCs pertinent to elements in instance documents, their attributes and their contents. They are called archetypes because there may be more than one element declaration that shares the same SCs (see ), and which therefore can be constrained by a common archetype.

Archetypes archetypeDefn NCName archetypeSpec archetypeSpec refinement* contentType ( attribute | attrGroupRef )* model exportControl contentType datatypeRef | contentModel | modelGroupRef model open | refinable | closed archetypeRef archetypeName archetypeName NCName schemaRef? refinement typeRef

The first three productions above provide the basic structure of the specification, and the last two provide for reference to the things specified. But note that the name of an archetype is not ipso facto the name of elements whose appearance in instances will be associated with the SCs of that archetype. The connection between an element name and an archetype is made by an elementDecl, see below.

Alongside for permitted attributes, SCs for contents are specified in an archetype (contentType). For elements which may contain only character data, this is by reference to a . Note that doing this by way of datatypeRef allows for specialization and even defaulting in a manner similar to attribute values. For other kinds of elements, an is required.

The extension of defaulting to element content is tentative.

0 2.54 0 2.54cm ]]>

Two approaches to defining an archetype for length: one with character data content constrained by a qualified reference to a built-in datatype, and one attribute, the other using two elements.

The way in which the concrete syntax defined and illustrated above realises the abstract syntax is not straightforward, because it is optimised to make simple cases simple. The datatypeQual option is allowed only if a type attribute is present. Similarly, the schemaName or schemaAbbrev, the default and the fixed attributes are allowed only if a type attribute is present. Finally, if a type attribute is present, it must reference a datatype, and the content attribute must be textOnly (or absent, in which case it defaults to textOnly). This is to handle the main alternation in the abstract syntax for contentType, which allows either (possibly locally qualified) reference to a datatype or a content model.

See previous note on the type definition issue.

The Constraint on Schemas obtains.

The Constraint on Schemas obtains.

The attr-decl-set definition wrt schema-validity obtains.

The attr-fullname definition wrt schema-validity obtains.

The Constraint on Schemas obtains.

The satisfy-as definition wrt schema-validity obtains.

The Schema Information Set Contribution obtains.

Attribute Declaration

Attribute declarations associate a name (which will appear as an attribute in start tags in instances) with SCs for the presence and value thereof.

Attributes attribute NCName datatypeRef? required exportControl datatypeRef datatypeName datatypeQual datatypeQual specialize? valueConstraint? valueConstraint default | fixed datatypeName NCName schemaRef? schemaRef (schemaAbbrev | schemaName)

The datatypeRef productions are repeated here for easy reference.

Attribute declarations provide for:

Requiring instances to have attributes;

Constraining attribute values to express a datatype.

0 ]]>

Four attributes are declared: one with no explicit SCs at all; two declared by reference to a built-in datatype, one with a default and a subrange qualification and one required to be present in instances; and one with a fixed value.

The maxOccurs attribute is FIXED at 1 for all attributes. Consistent with this, minOccurs can only be 0 or 1.

When attribute declarations are used in an archetype specification, each archetype provides its own symbol space for attribute names. E.g. an attribute named title within one archetype need not have the same datatypeRef as one declared within another archetype.

The attr-satisfy definition wrt schema-validity obtains.

What is the default attribute datatypeSpec?

The satisfy-attrs definition wrt schema-validity obtains.

The Schema Information Set Contribution obtains.

We've got a problem with namespace declarations: they're not attributes at the infoset level, so they can appear without compromising validity, except if there is a fixed or required declaration, and defaults should have the apparently desired effect. I.e., if a schema declares an attribute whose name is xmlns with a default or fixed value, does it change the infoset? Or if we allow QNames as such to be declared, xmlns:foo.

Attribute Group Definition *

&XSP1; can name a group of attributes so that they may be incorporated as a whole into archetype definitions:

Attribute groups attrGroupDefn NCName attrGroupSpec attrGroupSpec attribute* exportControl attrGroupRef attrGroupName attrGroupQual attrGroupName NCName schemaRef? attrGroupQual attribute

Attribute group definitions provide a construct to replace some uses of parameter entities.

<attrGroup name='myAttrGroup'> <attribute .../> ... </attrGroup> <archetype name='myelement' content='empty'> <attrGroupRef name='myAttrGroup'/> </archetype>

Define and refer to an attribute group. The effect is as if the attribute declarations in the group were present in the archetype definition.

There needs to be a Constraint on Schema which constrains the attributes which appear with an attrGroupRef: the name is the same as one of the attributes in the group, datatype and defaulting preserves substitutability, etc. There needs to be some discussion of what happens in case of name conflict between attrs as a result of an attr group ref.
Element Content Model

When content of elements is not constrained by reference to a datatype (), it can have any, empty, element-only or mixed content. In the latter cases, the form of the content is specified in more detail.

Content model contentModel any | empty | mixed | elemOnly

A content model constrains the element content of an archetype specification: it says nothing about attributes.

Content models do not have names, but appear as a part of the definition of an archetype, which does have a name. Model groups can be named and used by name, see below.

The satisfy-cm definition wrt schema-validity obtains.

Mixed Content

A content model for mixed content provides for mixing elements with character data in document instances. The allowed elements are named, but neither their order nor their number of occurrences is constrained.

Mixed content mixed ( elementRef | archetypeRef | elementDecl )*

The elementRefs and elementDecls determine the elements that may appear as children along with character data. For the interpretation of archetypeRef in this context, see .

<archetype content='mixed'> <element ref='name1'/> <element ref='name2'/> <element ref='name3'/> </archetype>

Allows character data mixed with any number of name1, name2 and name3 elements.

The fact that mixed allows for there to be no elementRefs or elementDecls makes it similar to XML 1.0's Mixed production. Indeed an empty mixed is the only way a schema can allow character data content with no datatype constraint at all.

The Constraint on Schemas obtains.

See for discussion and examples of the appearance of elementDecl above.

The satisfy-mixed definition wrt schema-validity obtains.

Element-Only Content

A content model for element-only content specifies only child elements (no immediate character data content other than white space is allowed). The content model consists of a simple grammar governing the allowed types of child elements and the order in which they must appear.

Element-only content elemOnly modelElt modelElt occurs ( modelGroup | modelGroupRef | elementRef | archetypeRef | elementDecl ) occurs minOccurs maxOccurs modelGroup richModelGroup | simpleModelGroup richModelGroup compositor modelElt modelEltSeq compositor sequence | choice modelEltSeq modelElt modelEltSeq? simpleModelGroup all simpleModelElt simpleModelEltSeq simpleModelElt elementRef | elementDecl | archetypeRef simpleModelEltSeq simpleModelElt simpleModelEltSeq? I'm unclear what the status of collection is after the Montreal votes, for the time being it's out.

The grammar for element-only content is built on model elements and model groups (modelElt and modelGroup above). A model element provides for some number of occurrences in an instance of either a single element (via elementRef or elementDecl) or a group of elements (via modelGroup or modelGroupRef). A model group is two or more model elements plus a compositor.

A compositor for a model group specifies for a given group whether it is a sequence of its model elements, a choice between its model elements or a set of its model elements which must appear in instances (this is the case for the implicit 'and' compositor, which is associated with the simpleModelGroup production. These options reconstruct the XML 1.0 , connector, the XML 1.0 | connector and the SGML & connector respectively. In the first case (sequence) all the model elements must appear in the order given in the group; in the second case (choice), exactly one of the model elements must appear in the element content; and in the third case (all), all the model elements, which are restricted in this case only to unqualified elementRefs and elementDecls, must appear in the element content, but may appear in any order.

The occurs specification governs how many times the instance material allowed by a modelElt may occur at that point in the grammar, but note that the components of a group whose compositor is (implicitly) 'all' are not qualified, and therefor call for exactly one appearance of the element they identify.

See for further discussion and examples of the appearance of elementDecl within modelElt above.

For the interpretation of archetypeRef in this context, see .

The satisfy-eo definition wrt schema-validity obtains.

The Constraint on Schemas obtains.

The Constraint on Schemas obtains.

Should this compatibility constraint be preserved?

Named Model Group *

This reconstructs another common use of parameter entities.

Named model groups modelGroupDefn NCName modelGroupSpec modelGroupSpec ( modelGroup | modelGroupRef ) exportControl modelGroupRef modelGroupName modelGroupName NCName schemaRef? <modelGroup name='myModelGroup'> <element ref='myelement'/> </modelGroup> <element name='myelement'> <archetype> <modelGroupRef name='myModelGroup'/> <attribute ...>. . .</attribute> </archetype> </element> <element name='anotherelement'> <archetype> <group order='choice'> <element ref='yetAnotherelement'/> <modelGroupRef name='myModelGroup'/> </group> <attribute ...>. . .</attribute> </archetype> </element>

A minimal model group is defined and used by reference, first as the whole content model, then as one alternative in a choice.

Element Declaration

An element declaration associates an element name with a type, either by reference or by incorporation.

Element declaration elementDecl NCName elementSpec elementSpec ( typeRef | archetypeSpec | datatypeSpec) exportControl global? typeRef archetypeRef | datatypeRef elementRef elementName elementName NCName schemaRef?

An element declaration associates a name with a specification. This name will appear in tags in instance documents; the specification provides SCs on the form of elements tagged with the given name. An element declaration whose elementSpec is an archetypeSpec is comparable to an <!ELEMENT ...> declaration in an XML 1.0 DTD.

elementSpec not only allows for element declarations to associate a name with an archetypeSpec (by reference or inclusion), but also allows the reference or specification to be for a datatype, with the implication that no attributes are allowed in instances and the text-only content will be constrained appropriately.

elementRef and elementName provide for top-level element declarations to be referenced by name from content models.

As noted above element names are in a separate symbol space from the symbol spaces for the names of types, so there can (but need not be) an archetype or datatype with the same name as a top-level element.

In the case of ambiguity of type reference, that is when the typeRef option is used and there are both a datatype and an archetype of the referenced name in the relevant schema, the ambiguity is resolved in favour of the archetype.

See previous note on the ambiguity issue.

The elt-fullname definition wrt schema-validity obtains.

An elementDecl may appear both at the top level of a schema and within a modelElt. See above ( and ) for where this is allowed. This declares a locally-scoped association between an element name and a type. As with attribute names, locally-scoped element names reside in symbol spaces local to the archetype that defines them. Note however that archetype and datatype names are always top-level names within a schema, even when associated with locally-scoped element names.

It is not yet clear whether a type defined implicitly by the appearance of a archetypeSpec or datatypeSpec directly within an elementSpec, or by the use of a typeRef which refers to a datatype, will have an implicit name, or if so what that name would be.

<element name='myelement' type='myDatatype'/> <element name='et0' type='myType'/> <element ref='et1'/> <element name='et1'> <archetype order='all'> <element . . . /> . . . <attribute ...>. . .</attribute> </archetype> </element> <element name='et2'> <archetype content='any'/> </element> <element name='et3'> <archetype content='empty'> <attribute ...>. . .</attribute> </archetype> </element> <element name='et4'> <archetype order='choice'> <element . . . /> . . . <attribute ...>. . .</attribute> </archetype> </element> <element name='et5'> <archetype order='seq'> <element . . . /> . . . <attribute ...>. . .</attribute> </archetype> </element> <element name='et6'> <archetype model='open' content='mixed'/> </element>

A pretty complete set of alternatives. Note the last one is intended to be equivalent to the idea sometimes called WFXML, for Well-Formed XML: it allows any content at all, whether defined in the current schema or not, and any attributes.

<element name='contextOne'> <archetype order='seq'> <element name='myLocalelement' type='myFirstType'/> <element ref='globalelement'/> </archetype> </element> <element name='contextTwo' <archetype order='seq'> <element name='myLocalelement' type='mySecondType'/> <element ref='globalelement'/> </archetype> </element>

Instances of myLocalelement within contextOne will be constrained by myFirstType, while those within contextTwo will be constrained by mySecondType.

The possibility that differing attribute declarations and/or content models would apply to elements with the same name in different contexts is an extension beyond the expressive power of a DTD in XML 1.0.

The Constraint on Schemas obtains.

The Constraint on Schemas obtains.

The satisfy-ed definition wrt schema-validity obtains.

The ind-valid definition wrt schema-validity obtains.

The satisfy-etr definition wrt schema-validity obtains.

Archetype Refinement *

This chapter articulates what has only been hinted at above, namely a considerable increase in the power and expressiveness of schema declarations, by explaining what was provided for in the abstract syntax in the previous section, but not explained much if at all at that point.

We provide for the refinement of archetypes defined in a schema. An archetype definition may identify one or more other archetypes from which it specifies the creation of a (joint) refinement.

The balance of this chapter has been withdrawn, pending further discussion in the WG. A Task Force created from within the WG has investigated a range of issues and options for implementing the desired functionality, as called for in the . The Task Force has produced a report , which will form the basis of a design to be filled in here.

Graveyard for stale syntax, here to avoid breaking IDREFs elsewhere *

an archetype AT1 is said to refine an archetype AT2 if and only if AT1 is declared to refine either AT2 or (recursively) some archetype that refines AT2. AT2 is then said to be an ancestor of AT1. The effective constraints are the union of the explicit and the acquired.

Entities and Notations * Entities and notations entityDecl NCName entitySpec entitySpec ( textEntitySpec | externalEntitySpec | unparsedEntitySpec ) exportControl? textEntitySpec string-value externalEntitySpec systemID publicID? exportControl? unparsedEntitySpec systemID notationRef publicID? exportControl? entityRef entityName entityName NCName schemaRef? notationDecl NCName notationSpec notationSpec systemID notationRef publicID? exportControl? systemID URI publicID see notationRef notationName notationName NCName schemaRef? Internal Parsed Entity Declaration *

Internal parsed entities are a feature of XML that enables reuse of text fragments by direct reference in an instance document.

In &XSP1; documents, internal parsed entities are declared by using the textEntitySpec production.

<textEntity name='flavor'>Fresh mint</textEntity'>

flavor can now be used in an entity reference in instances of the containing schema.

See for SCs covering entities and entity references.

External Parsed Entity Declaration *

External parsed entities are a feature of XML that offers a method for including well-formed XML document fragments, including text and markup, by direct reference to the storage object of the parsed entity.

In schemas, external parsed entities are declared by using the externalEntitySpec production.

<externalEntity name='FrontMatter' system='FrontMatter.xml' /> <externalEntity name='Chapter1' system='chapter1.xml' /> <externalEntity name='Chapter2' system='Chapter2.xml' /> <externalEntity name='BackMatter' system='BackMatter.xml' />

These four external entities represent the supposed contents of a book:

<book> &FrontMatter; &Chapter1; &Chapter2; &BackMatter; </book>

In an instance, the external entities take their familiar XML form. The processor expands the entities for their content.

Again, See for SCs covering entities and entity references.

Unparsed Entity Declaration *

External unparsed entities are a feature of XML that offers a baroque method for including binary data by indirect reference to both the storage object and the the notation type of the unparsed entity. In schemas, external parsed entities may be declared by using the unparsedEntitySpec production.

<unparsedEntity name='SKU-5782-pic' system='http://www.vendor.com/SKU-5782.jpg' notation='JPEG' /> <picture location='SKU-5782-pic'/>

The picture element carries an attribute which is (presumably) governed by the unparsed entity declaration.

The Schema Validity Constraint obtains.

There are lots of gaps and little problems in this design for unparsed entities.

Notation Declaration *

A notation may be declared by specifying a name and an identifier for the notation. A notation may be referenced by name in a schema as part of an external entity declaration.

<notation name='jpeg' public='image/jpeg' system='viewer.exe' /> <element name='picture> <archetype> <attribute name='entity' type='NOTATION'/> </archetype> </element> <picture entity='SKU-5782-pic'/>

The notation need not ever be mentioned in the instance document.

We need to synchronise with XML Schemas: Datatypes regarding how we declare attributes as unparsed entities!

Schema Composition and Namespaces * Introduction and TF report summary *

This chapter describes facilities to provide for validation of namespace-qualified instance document elements and attributes, and potentially (subject to enhancements to the Namespaces recommendation), entities and notations.

'Namespaces in XML' provides an enabling framework for modular composition of schemas. From that document:

We envision applications of Extensible Markup Language (XML) where a single XML document may contain elements and attributes (here referred to as a 'markup vocabulary') that are defined for and used by multiple software modules. One motivation for this is modularity; if such a markup vocabulary exists which is well-understood and for which there is useful software available, it is better to re-use this markup rather than re-invent it. Such documents, containing multiple markup vocabularies, pose problems of recognition and collision. Software modules need to be able to recognize the tags and attributes which they are designed to process, even in the face of 'collisions' occurring when markup intended for some other software package uses the same element or attribute name. These considerations require that document constructs should have universal names, whose scope extends beyond their containing document. This specification describes a mechanism, XML Schema namespaces, which accomplishes this.

&XSP1; provides facilities to enable declaration and modular composition of schemas.

The balance of this section as it appeared in the previous public WD has been withdrawn, pending further discussion in the WG. A Task Force created from within the WG has investigated a range of issues and options for implementing the desired functionality. The Task Force has produced a report , which will form the basis of a design to be filled in here.

I've chosen to include here a brief summary of the expected TF report, addressing the instance->schema connection issue, on the grounds that confusion is rampant in the rest of the world wrt this issue, and we will benefit both ourselves and others by signalling our thinking here as soon as possible.

The TF report recommends a layered approach, where the base layer simply addresses the process of schema validation where the element information item to be validated and the schema to validate it with are known. The second layer discusses mechanisms by which processors may locate schemas, but emphasises that this is always in the end an processor- and environment-dependent process. The following candidate mechanisms are identified:

The namespace URI of the item to be validated is dereferenced and yields a schema;

The namespace URI of the item to be validated is dereferenced and yields a package. A standard property of the package tells what kind of package it is and hence how to go about getting schema info out of it. We anticipate a great range of flexibility in the structuring and content of packages: schemas will certainly not be the only thing in them. All that matters to us is that we can get a schema out of them;

A URI is provided via a pre-defined attribute from the XML Schema namespace, which is dereferenced and yields a schema (or a package);

The namespace URI of the item to be validated is looked up via a catalogue or other binding mechanism, either locally or remotely, and yields a schema (or a package).

It is worth noting that the TF has not reached consensus on whether the above list should be understood as ordered, that is, in the case where more than one is viable, should we identify a precedence.

Graveyard for stale syntax, here to avoid breaking IDREFs elsewhere * Exporting Schema Constructs Export export allDatatypes? allArchetypes? allElements? allModelGroups? allAttributeGroups? allEntities? allNotations? allDatatypes boolean allArchetypes boolean allElements boolean allModelGroups boolean allAttributeGroups boolean allEntities boolean allNotations boolean exportControl boolean Schema Import Import import schemaAbbrev schemaName importRestrictions? Import Restrictions Import restrictions importRestrictions allDatatypes? allArchetypes? allElements? allModelGroups? allAttributeGroups? allEntities? allNotations? component* component componentName componentType componentName NCName componentType datatype | archetype | element | attrGroup | modelGroup | entity | notation Schema Inclusion Include include schemaRef allDatatypes? allArchetypes? allElements? allModelGroups? allAttributeGroups? allEntities? allNotations? component* Associating Instance Document Constructs with Corresponding Schemas
Documenting schemas *

Documentation facilities have purposely been left out of this draft of the XML Schema Definition Language specification. The editors chose to concentrate on other topics. It is anticipated that explanation elements will be provided for within any of the Schema elements. Their purpose is to encapsulate documentation for the elements within which they are contained. Elements for narrative exposition at the top level of a schema have also been proposed.

Proposals for XML Schema documentation include defining a custom set of elements, allowing any content at all, allowing all or part of , DocBook or TEI. There are good arguments for each of these proposals.

The Working Group must identify its requirements and constraints.

Conformance -- OUT OF DATE *

This draft includes extensive discussion of conformance and validity checking, but rules for dealing with errors are missing. In future, we must distinguish errors from fatal errors, and clarify rules for dealing with both.

Schema Validity *

This section is not up to date or in sync with the rest of the document, but is included here to avoid breaking huge numbers of references

We approach the definition of schema validity one step at a time. In the definitions below we deal primarily in terms of information sets, rather than the documents which give rise to them: see for definitions of item, RUE and information set.) Please note that the formal definitions below are explicitly not couched in processing terms: they describe properties of an information set, but do not tell you how to check an information set to see if it has those properties.

First we have to get to the schema(s) involved. This is slightly tricky, as not all namespace declarations will resolve to schemas, and not everything that purports to be a schema will be one.

A URI is said to nominate a schema if it resolves to an element item in the information set of a well-formed XML 1.0 document whose local name is schema and whose namespace item's URI identifies either

this specification or one of its successors,

the XML Schema 1.0 DTD (or the equivalent DTD from a successor to this specification)

or

The XML Schema 1.0 schema (or the equivalent schema from a successor to this specification).

A URI is said to resolve successfully to a schema if it nominates a schema, and the element item it resolves to represents an XML schema, that is:

If it were the document element item of an information set corresponding to an XML document whose DOCTYPE identified the XML Schema 1.0 DTD (or the equivalent DTD from a successor to this specification) as its DTD, that document would be valid per XML 1.0;

it and its descendants satisfy all Constraints on Schemas stated in this specification.

An element item is schema-ready if the URI of any of its namespace declaration items which nominates a schema resolves successfully to a schema.

Namespace items associated with namespace declarations have disappeared from the most recent version . Several WGs need them, we expect they'll be back, otherwise we can reconstruct what we need from element and attribute namespace items alone with some effort.

A document is schema-ready if every element item anywhere in its information set is schema-ready.

Note that this means that documents with no namespace declarations, or only namespace declarations which do not nominate schemas are none-the-less schema-ready.

We say an element item is schema-governed if its name is in a namespace, and the URI of the information item for that namespace resolves successfully to a schema.

We use the name schema root for any element item which is schema-governed and which is either

the document element

or

the daughter of an element which is not schema-governed.

The provision within &XSP1; of a mechanism for defining parsed entities presents problems for the relationship between schema-validity and XML 1.0 well-formedness, since references to entities declared only in a schema are undefined from the XML 1.0 perspective. Strictly speaking, a well-formed XML document may contain references to undefined entities only if it is declared as standalone='no' and contains either an external subset or one or more references to external parameter entities in their internal subset. We get around this by defining a nearly well-formed XML document to be one which either is well-formed per XML 1.0, or which fails to be well-formed only because of undefined general entity references, but which would be well-formed if it were standalone='no' and identified an external subset. We consider this justified on the grounds that the use of a namespace declaration which refers to a schema functions rather as an external subset, and from the XML 1.0 perspective such a reference almost of necessity renders the document non-standalone when schema-validation is applied.

We use the name string-infoset-in-context for the XML 1.0 information set items arising from the interpretation of a string in the context of a particular point in an XML 1.0 information set.

The effective element item of an element item (call this OEI) is an element item whose

name and namespace items (if any) are the same as those of OEI;

attribute item names and namespace items (if any) are the same as those of OEI;

attribute value items are the respective value items of OEI's attribute items with the string-infoset-in-context of the declared expansion of every RUE in those values replacing those RUEs;

children based on the children of OEI as follows:

Character, PI and comment child items carried over unchanged;

Element child items replaced with their respective effective element items;

RUE child items replaced by the string-infoset-in-context of their declared expansions, with any RUE or element item in that string-infoset-in-context itself being recursively replaced per this or the above definition respectively.

The Schema Validity Constraint obtains.

The Schema Validity Constraint obtains.

The Schema Validity Constraint obtains.

Note that the above constraints and definition mean that in error-free documents, all element items, even ones which are not schema-governed, have well-defined effective element items.

A document is schema-valid if and only if:

It is nearly-well-formed;

It is schema-ready;

Every schema root element item in the set of element items consisting of the effective element item of the document element item in the document's information set and all the element items anywhere inside that effective element item, is independently valid.

The validity of all other schema-governed element items follows from (3) above by the recursive nature of the Schema-validity Constraint referenced there.

It is intentional that the above definition labels as schema-valid a document with no namespace declarations or with only namespace declarations which do not nominate schemas.

Note that there is no requirement that the schema root mentioned above be the root of its document, or that schemas be the roots of their documents, or that schema and schema root be in different documents. Accordingly, it is possible for a single schema-valid document to contain both a schema and the material which it validates.

The interaction between XML 1.0 DTDs and XML Schemas is complex but clear:

A document may be well-formed, (DTD) invalid and schema-valid all at the same time;

If document has a DTD which includes parsed entity declarations, the schema-validation process may well apply to material whose original home was in those entities (internal or external);

Where or not a document has a DTD, the (XML 1.0) infoset we're schema-validating may well include 'RUE items', that is, references to unknown entities, unknown, that is, as far as the definitions of XML 1.0 are concerned. As long as the document's schema provides declarations for these 'undefined' entities, it still may be schema-valid.

The above is silent on whether schema-valid documents must be Namespace-conforming.

The augmented information set of a schema-valid document is the information set rooted in the effective element item of its document element, augmented by all the information items described in any Schema Information Set Contributions which apply to any information items anywhere within it.

Detailed validity constraints and definitions * The Schema * Unique Definition

The same NCName must not appear in two definitions or declarations of the same type.

References to Schema Constructs * Consistent Import

A schemaAbbrev or schemaName in a schemaRef must be declared in an of the current schema, and the NCName qualified by that schemaRef must be an import () of the appropriate type per that declaration.

One Reference Only

The concrete syntax uses schemaAbbrev and schemaName attributes to realise schemaName. It is an error for both these attributes to appear on the same element in a schema.

A ...Ref identifies a ...Spec provided there is a definition or declaration of that ...Spec in the appropriate schema whose NCName matches the NCName of the ...Ref's ...Name. If there is no schemaRef in the ...Name, the appropriate schema is the current schema or a schema it eventually includes; if there is a schemaRef, the URI contained in or abbreviated by it must resolve successfully to a schema, which is then the appropriate schema.

Types, Elements and Attributes * Datatypes * Avoid Built-ins

The NCName must not be the same as the name of any of the built-in datatypes (see ).

A string (possibly empty) dt-satisfies a datatypeSpec and an optional datatypeQual if

The string is a valid instance of the datatype defined by that datatypeSpec, as specialized by the datatypeQual's specialize (if present) (see for a definition of when a string is a valid instance of a (possibly specialized) datatypeSpec);

and

If there is a datatypeQual and it includes a fixed, the string matches that fixed value.

Datatype Info

When a string dt-satisfies a datatypeRef and an optional datatypeQual, the containing attribute or element information item will be augmented to indicate the datatypeSpec and the specialize (if any) which it satisfied.

Archetype Definition * AttrGroup Unique

The same attrGroupDefn must not be referenced by two or more attrGroupRefs in the same archetypeSpec.

AttrGroup Identified

Every attrGroupRef in an archetypeSpec must identify an attrGroupSpec.

The attribute declaration set of an archetypeSpec consists of all its effective attributes together with all the attributes contained in the attrGroupSpecs identified by any attrGroupRefs it contains.

The full name of an attribute in an attribute declaration set is its NCName plus its schemaName, i.e. if it appeared directly in the archetypeSpec, the empty string, if it was acquired by refinement or if it came from an attrGroupSpec, then the schemaName from the schemaRef which identified the relevant archetypeSpec or attrGroupSpec respectively, if any, otherwise the empty string.

Attribute Locally Unique

The same full name must not appear more than once in any archetypeSpec's attribute declaration set.

An element item a-satisfies an archetypeSpec if the element item's attribute items taken together as a set attrs-satisfy the archetypeSpec's attribute declaration set, and either

The archetypeSpec's contentType is a datatypeRef, the datatypeRef identifies a datatypeSpec, the element item contains only comment, processing instruction and character information items and the string formed by concatenating the characters of each of the character information item children, if any, or else the empty string, dt-satisfies that datatypeSpec as qualified by the datatypeRef's datatypeQual if any;

or

the contentType is a contentModel, and the sequence of character and element items contained by the element item model-satisfies its effective contentModel.

The above definitions do not provide for handling a default on an archetype's datatypeRef. Preferred solution: empty element items ipso facto satisfy datatypeRefs with defaults and are augmented with the default value. This would have the consequence that you cannot provide the empty string as the explicit value of an element item if it's governed by a datatypeRef with a default.

Archetype Info

When an element item a-satisfies a archetypeSpec, that element information item will be augmented to indicate the archetypeSpec which it satisfied.

Attribute Declaration *

An attribute item attr-satisfies an attribute if

The attribute contains no datatypeRef and the attribute item's value string dt-satisfies the default datatypeSpec for attributes

or

the attribute's datatypeRef identifies a datatypeSpec and the attribute item's value string dt-satisfies that datatypeSpec as qualified by the datatypeRef's datatypeQual if any

where the attribute item's value consists of only character information items and by its "value string" is meant the string formed by concatenating the characters of each of those character information item children, if any, or else the empty string.

The attribute items of an element item attrs-satisfy an attribute declaration set if

1) for each attribute item either

1a) there is an attribute in the attribute declaration set whose full name consists of an NCName which matches the attribute item's name and either

1a1) the attribute item has no namespace and the attribute's full name has no schemaName

or

1a2) the attribute item's namespace and the attribute's full name's schemaName are identical

and the attribute item attr-satisfies the declaration

or

1b) the archetypeSpec being a-satisfied by the attribute item's parent element item is open

and

2) every attribute in the attribute declaration set which is required is used to attr-satisfy an attribute item in the context of (1a) above

Attribute Value Default

For every attribute in the attribute declaration set not used to attr-satisfy an attribute item in the context of (1a) above which has a datatypeRef which has a default, an attribute item with the default value is added to the parent element item.

Element Content Model *

A sequence of character and element items (call this CESeq) model-satisfies an effective contentModel if

the sequence is empty and the effective contentModel is empty;

the effective contentModel is any and every element item in CESeq is independently valid, and for every element item in CESeq such that the schema which its namespace item resolves to is not the current schema there is an import whose schemaName is identical to that element item's namespace item's URI and that import must either be allElements or contain an elementRef whose NCName matches that element item's name;

the effective contentModel is mixed and every element item in CESeq mixed-satisfies the effective mixed

or

the effective contentModel is elemOnly and the only character items in CESeq are whitespace character items and the sub-sequence of CESeq consisting of all the element items therein eo-satisfies the effective elemOnly.

Mixed Content * Element Unique in Mixed

A given NCName must not appear two or more times among the elementDecls and elementRefs with no schemaRefs; a given elementName must not appear two or more times among the elementRefs.

An element item mixed-satisfies a mixed if

the mixed contains an elementRef which the element item ref-satisfies

or

the mixed contains an elementDecl whose NCName matches the element item's name, in which case the element item must e-satisfy that elementDecl

or

the archetypeSpec which effectively contains the mixed is open and the element item is independently valid.

There's an implicit change in current schema in the definition of satisfy-mixed above which should be made explicit.

Element-only Content *

A sequence of element items elemOnly-satisfies an effective elemOnly if

it is possible to trace out a path through the content model, obeying the compositor and occurs specifications and accepting each element item in the sequence with an elementRef or elementDecl in the content model. Accepting an element item from the sequence with an elementRef requires that it ref-satisfy that elementRef; accepting an element item with an elementDecl requires that the elementDecl's NCName matches the element item's name, in which case the element item must e-satisfy that elementDecl.

The above definition of elemOnly-satisfy does not explicitly incorporate the modifications required when the containing archetype is open, as set out at the end of , but it should be understood as doing so.

Element Consistency

A given NCName must not appear both among the elementDecls and among the elementRefs with no schemaRefs, or more than once among the elementDecls.

Note that the above permits repeated use of the same elementRef, analogous to DTD usage.

EDITORS: Add a COS for the checking of valid pairs of minOccurs and maxOccurs.

Unambiguous Content Model

For compatibility, it is an error if a content model is such that there exist element item sequences within which some item can match more than one occurrence of an elementRef or elementDecl in the content model.

Element Declaration *

The full name of a top-level elementDecl is its NCName plus its schemaName, i.e. if it appeared directly in the current schema or an include, the empty string, if it was imported, then the schemaName of that import, which must successfully resolved to its containing schema.

An element item e-satisfies an elementDecl if the elementDecl:

contains an archetypeSpec directly, and the element item a-satisfies that archetypeSpec;

or

the typeRef alternative is used in that elementDecl and it identifies an archetypeSpec and the element item a-satisfies that archetypeSpec.

Nested May Not Be Global

An elementSpec in a nested elementDecl must not be global.

Cannot Shadow Global

If a top-level elementSpec is global, then the NCName of its elementDecl must not be redeclared by any nested elementDecl in the same schema or any schema it eventually includes.

An element item is independently valid if there is a top-level elementDecl whose NCName matches its name in the schema its namespace item resolves to (or a schema that schema includes, in which case see the definition of identify for details on which declaration is used if there is more than one), and the element item must e-satisfy that elementDecl.

An element item ref-satisfies an elementRef if

the elementRef identifies an elementDecl whose NCName matches the element item's name and either

the elementDecl's full name has no schemaName, in which case the element item's namespace must be the same as its parent's namespace

or

the element item's namespace and the elementDecl's full name's schemaName are identical

in which case the element item must also e-satisfy the elementDecl.

or

the elementRef identifies an elementDecl (call this ETD1), the element item is independently valid and the elementDecl whereby it is independently validated contains or identifies an archetypeSpec which refines the archetypeSpec contained in or identified by ETD1.

The last clause above is much too complex, it needs to be split apart and built up in stages. It is this which allows elements based on refining archetypes to appear in place of those based on their ancestors.

Archetype Refinement * Allowed Refinements

An archetype must not refine one or more other archetypes unless all of the latter have been declared with either open or refinable (explicitly or by default: the default for model on any archetype which does not explicitly specify one is provided by the model of the schema itself, which in turn defaults to closed for compatibility). The same archetype must not be referenced more than once in the refinements list.

Entities and Notations * Attribute is Entity

When an attribute value is interpreted as a reference to an unparsed entity [How?!], the attribute value must identifies an unparsedEntitySpec (note that no schemaRef can be specified in this case); the NCName of the notationRef of that unparsedEntitySpec must identify a notationSpec; the resource specified by the systemID and publicID attribute must be available.

Import Restrictions * Refer to Schema

The URI associated with a schemaRef in any of the productions above must successfully resolve to a schema.

Name Consistently Defined

The NCName in each of the above productions must identify a declaration or definition of the corresponding class (element, archetype, etc.)

Use Only Exported Defns

It is not an error for a schema to explicitly import a construct which has not been exported. However, it is an error for a schema to attempt to use such construct.

Schema Inclusion * Preorder Priority for Included Definitions

When using a ...Ref to identify a ...Spec, if there is no appropriate matching declaration or definition in the current schema, but there is more than one eventually included schema which contains an appropriate matching declaration or definition, the ...Spec whose declaration or definition occurs first in a preorder traversal of the eventually included schemas is the one identified.

A schema directly includes another schema if the first schema has an include and the URI contained in or abbreviated by the schemaRef of that include resolves successfully to the second schema.

A schema eventually includes another schema if the first schema directly includes the second, or if the first schema directly includes some other schema which itself eventually includes the second.

Schema Validity * Expansions Schema-Ready

Any element item anywhere within the string-infoset-in-context replacing an RUE child per the above must be schema-ready.

Ungoverned RUE

RUEs must not appear in element items which are not schema-governed, that is in the values of attributes of or as children of such elements.

RUE Entity Declared

For every RUE appearing in a schema-governed element, there must be a parsed entity declaration in the referenced schema whose name matches the name of the RUE.

Responsibilities of Schema-aware processors *

This section has fallen out of alignment with the rest of the specification, but is included none-the-less to give a feeling for how this section will eventually look: the details should not be taken too seriously.

Each step in the following presupposes the successful outcome of the previous step.

A conforming XML Schema processor must:

Test for XML 1.0 well-formedness;

Construct the XML 1.0 information set. This will include identifying and distinguishing all namespace declarations and uses, and expanding any entity references whose XML 1.0 declarations are accessible;

Starting from the root, traverse the information set in pre-order until an element information item with a namespace declaration which refers to an accessible schema is found;

Schema-validate the information set subtree rooted at that element information item using that schema, i.e.

Expand the information set by replacing the remaining entity references as described in ;

Schema-validate the resulting information set, as described in ;

Expand the information set per all Schema Information Set Contributions encountered

for each namespace: its prefixes and URI, and access to a schema corresponding to that URI.

for each element: its name (URI+GI), its content, its datatype or archetype, its attributes

for each attribute: its name, its value(s), its datatype, and whether its presence is required on an element.

for each datatype: its names, its heritage (or type lattice), its value space, its refinable facets.

for data: its datatype (and type lattice), whether its presence is required, and its lexical constraints.

for each archetype: its name, its content model or datatype, its heritage (or type lattice), its attributes, and whether it is open/closed or can be refined.

for each element: its name, its datatype or archetype or content model, its attributes, and whether it is open/closed or can be refined.

for each model: whether it is any, empty, mixed, or a group of one or more elements -- in which case, the grammar of the group, and whether it is open/closed or can be refined.

Go back to (3) above and continue traversing, starting with the successor in document order to the item just schema-validated, unless there is no successor;

Provide for an external processing system to have access to the combined information set: document instance plus schema information.

Note that the schema contribution to the information set above is meant to be suggestive only at this point, until we've articulated all the Schema Information Set Contributions in the preceding sections.

Lexical representation *

The editors did not get to this.

Information set *

The editors did not get to this.

(normative) Schema for Schemas *

The XML Schema definition for &XSP1; itself is presented here as normative part of the specification, and as an illustrative example of the XML Schema in defining itself with the very constructs that it defines. The names of XML Schema language types, elements, attributes and groups defined here are evocative of their purpose, but are occasionally verbose.

There is some annotation in comments, but a fuller annotation will require the use of embedded documentation facilities or a hyperlinked external annotation for which tools are not yet readily available.

Since an &XSP1; is an XML document, it has optional XML and doctype declarations that are provided here for completeness. The root schema element defines a new schema. Since this is a schema for &XSP1;, the targetNS references the XML Schema namespace itself, and specifies that this is version "&XSP1.version;".

In the following definition of the schema element, the preamble is realised with attributes corresponding to targetNamespace, schemaVersion and model, and a sequence of nested elements for import, export and include. The xmlns attribute corresponds to xmlSchemaRef. The schema's definitions and declarations are represented by datatype, archetype, element, attribute, attrGroup, modelGroup, textEntity, externalEntity, unParsedEntity and notation.

open refinable closed choice seq all elemOnly textOnly mixed empty any open refinable closed 0 1 datatype archetype element attrGroup modelGroup entity notation ]]>

And that is the end of the schema for &XSP1;.

(normative) DTD for Schemas *

The DTD for &XSP1; is given below. Note there is no implication here the schema must be the root element of a document.

%xs-datatypes; ]]>
Glossary (normative) * The Glossary has barely been started. An XSL macro will be used to collect definitions from throughout the spec and gather them here for easy reference.

theabstract syntax of the XML Schema Definition Language is ...

an aggregate datatype is

an type is

an type reference is

the 'all' content model group is

the 'any' content specification ...

an atomic datatype is

an attribute is

an attribute group is

the 'choice' content model group is

composition is

the concrete syntax is

a constraint is

content is

a context is

an datatype is

an datatype reference is

a default value is

a document is

an element is

element content is

an element reference is

the 'empty' content specification ...

to export is

an export control

an external entity is

a facet is

a fixed value

a fragment is

to import is

to include is

an information set is

an instance is

markup is

the 'mixed' content specification ...

a model is

a model group is

a model group reference is

RUE is short for reference to undefined entity information item as defined in

an NCName is a name with no namespace qualification, as defined in . Appears in all the definition and declaration productions of this specification.

a namespace is

a notation is

an object model is

occurrence is

a parameter entity is

a preamble is

presence is

refinement is

the document root is ...

scope is

the 'sequence' content model group is

structure is

a symbol space is

a parsed entity is

an unparsed entity is

validation is

a vocabulary is

well-formedness is

References (normative) * Fourth Meeting of the &SchemaWG;. See http://www.w3.org/XML/Group/1999/04/xml-schema-ftf.html Document Content Description for XML (DCD), Tim Bray et al. W3C, 10 August 1998. See http://www.w3.org/TR/NOTE-dcd Document Definition Markup Language. See http://www.w3.org/TR/NOTE-ddml HTML 4.0 Specification, Dave Raggett et al. W3C, 1998. See http://www.w3.org/TR/REC-html40 ISO 11404 -- Information Technology -- Programming Languages, their environments and system software interfaces -- Language-independent datatypes, ISO/IEC 11404:1996(E). RFC 1808,Relative Uniform Resource Locators. Internet Engineering Task Force. See http://ds.internic.net/rfc/rfc1808.txt Schema for Object-oriented XML, Matt Fuchs, et al. W3C, 1998. See http://www.w3.org/Submission/1998/15/ Schema for Object-oriented XML, Version 1.1, Matt Fuchs, et al. W3C, 1999. See ??? Uniform Resource Identifiers (URI): Generic Syntax and Semantics. See http://www.ics.uci.edu/pub/ietf/uri/draft-fielding-uri-syntax-01.txt RFC 1738,Uniform Resource Locators (URL). Internet Engineering Task Force. See http://ds.internic.net/rfc/rfc1738.txt RFC 2141,URN Syntax. Internet Engineering Task Force. See http://ds.internic.net/rfc/rfc2141.txt WAI Accessibility Guidelines: Page Authoring, Gregg Vanderheiden et al. W3C, 14-Apr-1998. See http://www.w3.org/TR/WD-WAI-PAGEAUTH Web Architecture: Extensible Languages, Tim Berners-Lee and Dan Connolly. W3C, 10 Feb 1998. See http://www.w3.org/TR/NOTE-webarch-extlang Proposed TC for WebSGML Adaptations for SGML, C. F. Goldfarb, ed., 14 June 1997. See http://www.sgmlsource.com/8879rev/n1929.htm XML Schema Part 2: Datatypes, Paul V. Biron and Ashok Malhotra, eds. See &XSP2.URI;.html XML Schema Requirements , Ashok Malhotra and Murray Maloney, ed., W3C, 15 February 1999. See http://www.w3.org/TR/NOTE-xml-schema-req XML-Data Reduced, Frankston, Charles, and Henry S. Thompson, ed. See http://www.ltg.ed.ac.uk/~ht/XMLData-Reduced.htm XML Linking Language (XLink), Eve Maler and Steve DeRose, W3C, 3 March 1998. See http://www.w3.org/TR/WD-xlink Extensible Markup Language (XML) 1.0, Tim Bray, et al. W3C, 10 February 1998. See http://www.w3.org/TR/REC-xml Extensible Stylesheet Language Transformations, James Clark, W3C, 21 April 1999. See http://www.w3.org/TR/1999/WD-xslt-19990421 XML-Data, Andrew Layman, et al. W3C, 05 January 1998. See http://www.w3.org/TR/1998/NOTE-XML-data-0105 XML Information Set (first public WD), David Megginson et al., W3C, 1999. See http://www.w3.org/XML/Group/1999/04/WD-xml-infoset-19990428.html Namespaces in XML, Tim Bray et al., W3C, 1998. See http://www.w3.org/TR/WD-xml-names XML Pointer Language (XPointer), Eve Maler and Steve DeRose, W3C, 3 March 1998. See http://www.w3.org/TR/WD-xptr XSchema Specification, Simon St. Laurent, Ronald Bourret, John Cowan, et al., Version 1.0, Draft, 18 October 1998. See http://www.simonstl.com/xschema/spec/xscspecv4.htm For more general information, consult http://purl.oclc.org/NET/xschema Task Force Reports (non-normative) * Composition TF Report XML Schema Composition Task Force Report: Partial draft, Noah Mendelsohn, Henry S. Thompson. See &XSP1.base;/&WD-XSP1;/composition-tf.html Refinement TF Report Refinement Task Force Report, Eve Maler, Ashok Malhotra, and Allen Brown eds. See &XSP1.base;/&WD-XSP1;/refinement-tf.html Simple TF Background Proposal by the "Simple Syntax" Taskforce, David Fallside et al. See &XSP1.base;/&WD-XSP1;/simple-background.html Simple TF Proposal XML Schema Part 1: Structures - Proposed Updates from Simplification Task Force, David Fallside et al. See &XSP1.base;/&WD-XSP1;/simple-proposal.html Grateful Acknowledgments (non-normative) *

The editors the acknowledge the members of the &SchemaWG;, the members of other W3C Working Groups, and industry experts in other forums who have contributed directly or indirectly to the process or content of creating this document. The editors are particularly grateful to Lotus Development Corp. for providing teleconferencing facilities.

Sample Schema (non-normative) *

An example of a full blown schema, for the PurchaseOrder example from :

&XSP1.base; 0 ]]>
Tabulation of changes * schema alternatives Revision 1.10.2.30 1999/09/22 14:02:35 ht typo in correction to 4.1 Revision 1.10.2.29 1999/09/22 13:58:39 ht edits implementing Noah's comments Revision 1.10.2.28 1999/09/22 08:07:07 ht add verbatim change log at end ---------------------------- revision 1.10.2.27 date: 1999/09/21 16:26:11; author: ht; state: Exp; lines: +4 -4 added $Id: structures.xml,v 1.1 1999/09/24 18:18:56 hugo Exp $ to title for now ---------------------------- revision 1.10.2.26 date: 1999/09/21 16:06:08; author: ht; state: Exp; lines: +42 -244 replaced composition tf report with a summary and a pointer ---------------------------- revision 1.10.2.25 date: 1999/09/21 14:11:50; author: aqw; state: Exp; lines: +495 -111 some dates, up-to-date DTD and Schema for schemas ---------------------------- revision 1.10.2.24 date: 1999/09/21 10:50:37; author: ht; state: Exp; lines: +18 -3 supply missing content model for 'attribute' in concrete syntax paradigm ---------------------------- revision 1.10.2.23 date: 1999/09/21 10:37:51; author: aqw; state: Exp; lines: +21 -20 define/declare consistency pass ---------------------------- revision 1.10.2.22 date: 1999/09/20 13:08:36; author: aqw; state: Exp; lines: +47 -49 track datatype content model changes, minor wording ---------------------------- revision 1.10.2.21 date: 1999/09/16 14:55:17; author: ht; state: Exp; lines: +136 -14 header disclaimer, graveyards rescued to discharge references ---------------------------- revision 1.10.2.20 date: 1999/09/16 14:25:01; author: aqw; state: Exp; lines: +274 -1541 rip out all of 3.5, all of 4, install 'Draft Proposal' in 4 ---------------------------- revision 1.10.2.19 date: 1999/09/16 12:08:59; author: aqw; state: Exp; lines: +107 -143 Clean up import/include/export, references in particular Add archetypeRef to content models, minimally New example of datatype+attr ---------------------------- revision 1.10.2.18 date: 1999/09/15 22:06:29; author: aqw; state: Exp; lines: +26 -3 Two clarifications following discussion with andrew 1) what it would take to remove the two symbol spaces problem 2) How allows either datatypeRef or contentType ---------------------------- revision 1.10.2.17 date: 1999/09/15 20:30:49; author: aqw; state: Exp; lines: +114 -105 change date, incorporate edited dtd ---------------------------- revision 1.10.2.16 date: 1999/09/15 19:52:39; author: aqw; state: Exp; lines: +90 -76 Encorporate/respond to Eve Maler's suggested edits ---------------------------- revision 1.10.2.15 date: 1999/09/13 16:14:12; author: aqw; state: Exp; lines: +306 -335 Finish consistency pass through 3.4 Brutal 'element type' -> element ---------------------------- revision 1.10.2.14 date: 1999/09/09 14:22:29; author: aqw; state: Exp; lines: +53 -56 cleanup pass, down to 3.3 ---------------------------- revision 1.10.2.13 date: 1999/09/08 18:23:47; author: ht; state: Exp; lines: +41 -41 more type back to archetype ---------------------------- revision 1.10.2.12 date: 1999/09/08 18:03:06; author: aqw; state: Exp; lines: +214 -216 put archetype back in, imperfectly, I expect ---------------------------- revision 1.10.2.11 date: 1999/09/07 21:50:36; author: bu; state: Exp; lines: +124 -63 fix paradigm contexts, extend example, consolidate example in appendix ---------------------------- revision 1.10.2.10 date: 1999/09/07 16:54:39; author: aqw; state: Exp; lines: +514 -521 syntax paradigms now properly distributed, I think ---------------------------- revision 1.10.2.9 date: 1999/09/07 15:53:06; author: ht; state: Exp; lines: +5 -8 fixed minor validity errors ---------------------------- revision 1.10.2.8 date: 1999/09/07 15:31:58; author: aqw; state: Exp; lines: +288 -285 working on integrating syntax paradigms ---------------------------- revision 1.10.2.7 date: 1999/09/07 09:44:57; author: aqw; state: Exp; lines: +630 -33 added ALL concrete syntax boxes at once ---------------------------- revision 1.10.2.6 date: 1999/09/06 14:55:04; author: ht; state: Exp; lines: +35 -2 added one e: syntax exposition ---------------------------- revision 1.10.2.5 date: 1999/09/02 15:28:27; author: ht; state: Exp; lines: +6 -6 fix URLs for self, a bit ---------------------------- revision 1.10.2.4 date: 1999/09/02 12:53:34; author: aqw; state: Exp; lines: +108 -95 Added not-status-quo marks, changed e.g. String to string ---------------------------- revision 1.10.2.3 date: 1999/09/01 17:02:14; author: aqw; state: Exp; lines: +587 -977 integration of 2.3 from simple more renaming ---------------------------- revision 1.10.2.2 date: 1999/08/23 15:32:16; author: aqw; state: Exp; lines: +730 -248 Modified simple integration to give preliminary consistency ---------------------------- revision 1.10.2.1 date: 1999/08/22 17:44:40; author: aqw; state: Exp; lines: +317 -260 Textual integration of Simple update of 1999-08-13 ---------------------------- revision 1.10 date: 1999/07/20 19:47:27; author: ht; state: Exp; lines: +5 -5 branches: 1.10.2; fixed dates, dangling reference ---------------------------- revision 1.9 date: 1999/07/19 09:31:26; author: ht; state: Exp; lines: +34 -38 David Beech: updated definition of "Schema" following WG and IG email discussion. Changed "Schemata" to "Schemas" except where directly quoted from Requirements doc. Clarified in 2.5 that elements and attributes have separate symbol spaces (public comment). Fixed assorted typos. ---------------------------- revision 1.8 date: 1999/06/23 10:00:31; author: aqw; state: Exp; lines: +1 -1 fix $Id: structures.xml,v 1.1 1999/09/24 18:18:56 hugo Exp $ ---------------------------- revision 1.7 date: 1999/06/23 09:51:15; author: aqw; state: Exp; lines: +28 -28 Restrict content model of 'all' in schema and dtd, change entities for point releases ---------------------------- revision 1.6 date: 1999/06/23 09:10:01; author: aqw; state: Exp; lines: +147 -187 pushed & down to lowest level, fixed incoherent validity definition in 6.2.3.7 to agree with the note which follows. Wrapped validation text from 3.4 in appropriately named div4's ---------------------------- revision 1.5 date: 1999/06/21 16:31:59; author: aqw; state: Exp; lines: +569 -551 Really moved validity-oriented definitions to 6.3 (previous revision was just housekeeping) ---------------------------- revision 1.4 date: 1999/06/21 16:25:21; author: aqw; state: Exp; lines: +45 -36 moved validity-oriented definitions to 6.3 ---------------------------- revision 1.3 date: 1999/06/21 12:25:21; author: aqw; state: Exp; lines: +3540 -3650 Low-level: Normalise line ends, quotes Editorial: Move all constraintnotes to new separate section ---------------------------- revision 1.2 date: 1999/05/27 14:13:54; author: aqw; state: Exp; lines: +2 -2 fix stylesheet and dtd urls to local versions ---------------------------- revision 1.1 date: 1999/05/23 16:51:11; author: ht; state: Exp; branches: 1.1.1; Initial revision ]]> Open Issues *

A tabulation of open issues flagged above follows: