RELAX Data (datatypes)
XML DTD and Relax Schema

URL:   http://groups.yahoo.com/group/reldeve/message/287
From:  Kohsuke KAWAGUCHI
Date:  Thu Apr 5, 2001  12:36 am
Subject:  RELAX Data DTD

* changed content model to (element|ref|attribute)*
* changed "name" attribute of <export> to "label".


<?xml version="1.0" encoding="utf-8"?>
<!--
DTD for RELAX Data (Ver 1.0)
$Id$
-->

<!ENTITY % datatype "User_defined_datatypes_are_disallowed_at_least_now">
<!ENTITY % datatype-definitions SYSTEM "datatypes.dtd">
%datatype-definitions;

<!--*******************************************************-->
<!--                                                       -->  
<!--         The overall structure of RELAX modules.       -->
<!--                                                       -->  
<!--*******************************************************-->

<!ELEMENT interface ((%annotation;)?, (export | div)*)>

<!ELEMENT module ((%annotation;)?, interface?, 
                       (complexType | div | include )*)>

<!ATTLIST module
                 moduleVersion    CDATA      #IMPLIED
                 relaxDataVersion CDATA      #REQUIRED
                 targetNamespace  CDATA      #IMPLIED
                 xmlns            CDATA      #FIXED
"http://www.xml.gr.jp/xmlns/relaxData"
>
        
<!--*******************************************************-->
<!--                                                       -->  
<!--                          div                          -->
<!--                                                       -->  
<!--*******************************************************-->

<!ELEMENT div ((%annotation;)?,
               div*,
               (((%rule; | include ),
                 (%rule; | include | div)*)
                |
                (export, (export | div)*))?)>

<!-- 

(%rule; |%clause; | include | div)* is used when a div appears in a
module body, while (export | div)* is used when it appears in an
interface element.

 -->

<!ENTITY % rule "(complexType | simpleType)">
        

<!--*******************************************************-->
<!--                                                       -->  
<!--                       Interface                       -->
<!--                                                       -->  
<!--*******************************************************-->

<!ELEMENT export ((%annotation;)?)>
<!ATTLIST export
        type   NMTOKEN #REQUIRED
        label  NMTOKEN #REQUIRED
>
<!-- The name will be referenced as a label -->


<!--*******************************************************-->
<!--                                                       -->  
<!--                       Include                         -->
<!--                                                       -->  
<!--*******************************************************-->

<!ELEMENT include ((%annotation;)?)>
<!ATTLIST include moduleLocation CDATA #REQUIRED>


<!--*******************************************************-->
<!--                                                       -->  
<!--                    Hedge Models                       -->
<!--                                                       -->  
<!--*******************************************************-->


<!ENTITY % contentModel "( ref |  element | attribute )*">


<!ENTITY % repeatable '
                 minOccurs       CDATA      #IMPLIED
                 maxOccurs       CDATA      #IMPLIED
'>


<!ELEMENT ref EMPTY >
<!ATTLIST ref 
                 type      NMTOKEN      #REQUIRED
                 namespace CDATA        #IMPLIED
>

<!ELEMENT element ((%annotation;)?, (%facet;)*)>
<!ATTLIST element 
                 name     NMTOKEN #REQUIRED
                 type     NMTOKEN #REQUIRED
                 %repeatable;
>

<!--*******************************************************-->
<!--                                                       -->  
<!--                       types                           -->
<!--                                                       -->  
<!--*******************************************************-->


<!ELEMENT complexType  ((%annotation;)?, (%contentModel;) >
<!ATTLIST complexType
                name       NMTOKEN #REQUIRED
                baseType   NMTOKEN #IMPLIED
>

<!ELEMENT simpleType   (restriction|union|list) >
<!ATTLIST simpleType
                name       NMTOKEN #REQUIRED
>

<!ELEMENT restriction  (simpleType?, (%facet;)*) >
<!ATTLIST restriction
                base        NMTOKEN #IMPLLIED
>

<!ELEMENT list         (simpleType?) >
<!ATTLIST list
                itemType    NMTOKEN #IMPLIED
>

<!ELEMENT union        (simpleType*) >
<!ATTLIST union
                memberTypes CDATA #IMPLIED
>

<!ELEMENT attribute ((%annotation;)?, (%facet;)*) >
<!ATTLIST attribute
                 name      NMTOKEN      #REQUIRED
                 required   (true)      #IMPLIED
                 type      NMTOKEN      #IMPLIED
>

---------------------------------------------------------

URL:   http://groups.yahoo.com/group/reldeve/message/289
From:  Kohsuke KAWAGUCHI
Date:  Thu Apr 5, 2001  2:08 am
Subject:  Re: RELAX Data by RELAX Core.


RELAX Data schema written by RELAX Core.



<?xml version="1.0" encoding="UTF-8"?>
<module xmlns="http://www.xml.gr.jp/xmlns/relaxCore" moduleVersion="1.0"
relaxCoreVersion="1.0" targetNamespace="http://www.xml.gr.jp/xmlns/relaxData">

        <interface>
                <export label="module"/>
        </interface>
        
        <include moduleLocation="datatypes.rxm"/>
        
        
        
<!--*******************************************************-->
<!--                                                       -->  
<!--         The overall structure of RELAX modules.       -->
<!--                                                       -->  
<!--*******************************************************-->
        
        <elementRule role="annotation" type="string" />
        <tag name="annotation" />
        
        <hedgeRule label="annotations">
                <ref label="annotation" occurs="?"/>
        </hedgeRule>
        
        <hedgeRule label="moduleBody">
                <choice occurs="*">
                        <ref label="complexType"/>
                        <ref label="simpleType"/>
                        <ref label="div.inModule"/>
                        <ref label="include"/>
                </choice>
        </hedgeRule>
        
        <elementRule role="module">
                <sequence>
                        <hedgeRef label="annotations"/>
                        <ref label="interface"/>
                        <hedgeRef label="moduleBody"/>
                </sequence>
        </elementRule>
        <tag name="module">
                <attribute name="moduleVersion"/>
                <attribute name="relaxDataVersion" required="true" type="string">
                        <enumeration value="1.0"/>
                </attribute>
                <attribute name="targetNamespace" type="anyURI"/>
        </tag>
        
        <elementRule role="div.inModule">
                <hedgeRef label="moduleBody"/>
        </elementRule>
        <tag name="div" role="div.inModule"/>
        
        
        
<!--*******************************************************-->
<!--                                                       -->  
<!--                       Interface                       -->
<!--                                                       -->  
<!--*******************************************************-->
        
        <!-- type for type name of complex/simpleType. -->
        <simpleType name="typeT">
                <restriction base="NMTOKEN"/>
        </simpleType>
        
        <hedgeRule label="interfaceBody">
                <sequence>
                        <hedgeRef label="annotations"/>
                        <choice occurs="*">
                                <ref label="export"/>
                                <ref label="div.inInterface"/>
                        </choice>
                </sequence>
        </hedgeRule>
        
        <elementRule role="interface">
                <hedgeRef label="interfaceBody"/>
        </elementRule>
        <tag name="interface"/>
        
        <elementRule role="export">
                <hedgeRef label="annotations"/>
        </elementRule>
        <tag name="export">
                <attribute name="label" required="true" type="NMTOKEN"/>
                <attribute name="type" required="true" type="typeT"/>
        </tag>
        
        <elementRule role="div.inInterface">
                <hedgeRef label="interfaceBody"/>
        </elementRule>
        <tag role="div.inInterface" name="div"/>
        
        
        
<!--*******************************************************-->
<!--                                                       -->  
<!--                       Include                         -->
<!--                                                       -->  
<!--*******************************************************-->
        
        <elementRule role="include">
                <hedgeRef label="annotations"/>
        </elementRule>
        <tag name="include">
                <attribute name="moduleLocation" required="true" type="anyURI"/>
        </tag>
        
        
        
<!--*******************************************************-->
<!--                                                       -->  
<!--                    Hedge Models                       -->
<!--                                                       -->  
<!--*******************************************************-->
        
        <simpleType name="maxOccursType">
                <union itemTypes="nonNegativeInteger">
                        <simpleType>
                                <restriction base="string">
                                        <enumeration value="unbounded"/>
                                </restriction>
                        </simpleType>
                </union>
        </simpleType>
        
        <attPool role="repeatable">
                <attribute name="minOccurs" type="nonNegativeInteger"/>
                <attribute name="maxOccurs" type="maxOccursType"/>
        </attPool>
        
        <elementRule label="ref" role="ref.local">
                <empty/>
        </elementRule>
        <tag role="ref.local" name="ref">
                <attribute name="type" required="true" type="typeT"/>
                <attribute name="namespace" type="none"/>
                <attribute name="label" type="none"/>
        </tag>
        
        <elementRule label="ref" role="ref.external">
                <empty/>
        </elementRule>
        <tag role="ref.external" name="ref">
                <attribute name="type" type="none"/>
                <attribute name="namespace" type="anyURI" required="true"/>
                <attribute name="label" type="NMTOKEN" required="true"/>
        </tag>
        
        <elementRule role="element">
                <sequence>
                        <hedgeRef label="annotations"/>
                        <hedgeRef label="facet" occurs="*"/>
                </sequence>
        </elementRule>
        <tag name="element">
                <attribute name="name" required="true" type="NCName"/>
                <attribute name="type" required="true" type="typeT"/>
        </tag>
        
        <elementRule role="attribute">
                <sequence>
                        <hedgeRef label="annotations"/>
                        <hedgeRef label="facet" occurs="*"/>
                </sequence>
        </elementRule>
        <tag name="attribute">
                <attribute name="name" required="true" type="NCName"/>
                <attribute name="type" required="true" type="typeT"/>
        </tag>
        
        
        
<!--*******************************************************-->
<!--                                                       -->  
<!--                       types                           -->
<!--                                                       -->  
<!--*******************************************************-->
        
        <hedgeRule label="contentModel">
                <choice occurs="*">
                        <ref label="ref"/>
                        <ref label="element"/>
                        <ref label="attribute"/>
                </choice>
        </hedgeRule>
        
        <elementRule role="complexType">
                <sequence>
                        <hedgeRef label="annotations"/>
                        <hedgeRef label="contentModel"/>
                </sequence>
        </elementRule>
        <tag name="complexType">
                <attribute name="name" type="typeT" required="true"/>
                <attribute name="baseType" type="typeT"/>
        </tag>
        
</module>