dtdschematron.xsl

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheetxmlns:sch="http://purl.oclc.org/dsdl/schematron"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:functx="http://www.functx.com"version="2.0"exclude-result-prefixes="#all">

 <xsl:outputmethod="xml"encoding="UTF-8"indent="yes"/>

 <xsl:strip-spaceelements="*"/>

 <xsl:paramname="complete"select="'no'"/>

 <xsl:templatematch="/">
 <sch:schema>
 <sch:title>
 <xsl:text>ISO Schematron file created from </xsl:text>
 <xsl:value-ofselect="if(declarations/title) then declarations/title else /declarations/dtd/@relSysId"/>
 </sch:title>
 <sch:nsprefix="mml"uri="http://www.w3.org/1998/Math/MathML"/>
 <sch:nsprefix="xsi"uri="http://www.w3.org/2001/XMLSchema-instance"/>
 <sch:nsprefix="xlink"uri="http://www.w3.org/1999/xlink"/>
 <sch:patternid="heading">
 <sch:rulecontext="/">
 <sch:reporttest="*">Report date: <sch:value-ofselect="current-dateTime()"/></sch:report>
 </sch:rule>
 </sch:pattern>
 <xsl:apply-templatesselect="declarations/*"/>
 </sch:schema>
 </xsl:template>

 <xsl:templatematch="declarations/dtd | declarations/title"/>

 <xsl:templatematch="elements">
 <sch:patternid="elements">
 <sch:title>Element Checks</sch:title>
 <xsl:apply-templates/>
 </sch:pattern>
 </xsl:template>

 <xsl:templatematch="attributes">
 <xsl:iftest="attribute[annotations/annotation[@type='schematron']]">
 <sch:patternid="user-attributes">
 <sch:title>User Attribute Checks</sch:title>
 <xsl:apply-templatesselect="attribute[annotations/annotation[@type='schematron']]"/>
 </sch:pattern>
 </xsl:if>
 <xsl:if
test="$complete='yes' and attribute[attributeDeclaration[@mode='#REQUIRED']] or attribute[attributeDeclaration[@mode='#FIXED']] or attribute[attributeDeclaration[starts-with(@type, '(') and @mode!='#FIXED']]">
 <sch:patternid="dtd-attributes">
 <sch:title>DTD Attribute Checks</sch:title>
 <xsl:apply-templates
select="attribute[attributeDeclaration[@mode='#REQUIRED']] | attribute[attributeDeclaration[@mode='#FIXED']] | attribute[attributeDeclaration[starts-with(@type, '(') and @mode!='#FIXED']]"
 />
 </sch:pattern>
 </xsl:if>
 </xsl:template>

 <xsl:templatematch="generalEntities|parameterEntities"/>

 <xsl:templatematch="element">
 <xsl:variablename="element"select="concat('&lt;', @name, '&gt;')"/>
 <xsl:variablename="e-name">
 <xsl:value-ofselect="@name"/>
 </xsl:variable>
 <xsl:iftest="annotations/annotation[@type='schematron'] or $complete='yes'">
 <sch:rulecontext="{@name}">
 <xsl:apply-templatesselect="annotations/annotation[@type='schematron']"/>

<!--<xsl:comment><xsl:value-of select="content-model/@minified"/></xsl:comment>-->
 <xsl:choose>
 <xsl:whentest="$complete = 'no'"/>
 <xsl:otherwise>
 <xsl:apply-templatesselect="/declarations/attributes"mode="element">
 <xsl:with-paramname="element"select="$element"/>
 <xsl:with-paramname="e-name"select="$e-name"/>
 </xsl:apply-templates>
 <xsl:call-templatename="model-entities">
 <xsl:with-paramname="str"select="substring-after(content-model/@minified, '(')"/>
 </xsl:call-template>
 <xsl:apply-templatesselect="content-model/@minified">
 <xsl:with-paramname="element"select="$element"tunnel="yes"/>
 </xsl:apply-templates>
 </xsl:otherwise>
 </xsl:choose>
 </sch:rule>
 </xsl:if>
 </xsl:template>

 <xsl:templatematch="attribute[annotations/annotation[@type='schematron']]">
 <sch:rulecontext="{concat('@', @name)}">
 <xsl:apply-templatesselect="annotations/annotation[@type='schematron']/*"/>
 </sch:rule>
 </xsl:template>

 <xsl:templatematch="attribute[attributeDeclaration[@mode='#REQUIRED']] | 
 attribute[attributeDeclaration[@mode='#FIXED']] | 
 attribute[attributeDeclaration[starts-with(@type, '(') and @mode!='#FIXED']]">
 <xsl:variablename="attribute"select="concat('@', @name)"/>
 <xsl:apply-templates
select="attributeDeclaration[@mode='#REQUIRED'], 
 attributeDeclaration[@mode='#FIXED'], 
 attributeDeclaration[starts-with(@type, '(') and @mode!='#FIXED']">
 <xsl:with-paramname="attribute"select="$attribute"/>
 </xsl:apply-templates>
 </xsl:template>

 <xsl:templatematch="annotation[@type='schematron']">
 <xsl:apply-templates/>
 </xsl:template>

 <xsl:templatematch="annotation[@type='schematron']/*">
 <xsl:choose>
 <xsl:whentest="self::report">
 <sch:report>
 <xsl:for-eachselect="@*">
 <xsl:attributename="{./name()}">
 <xsl:value-ofselect="normalize-space(.)"/>
 </xsl:attribute>
 </xsl:for-each>
 <xsl:apply-templatesselect="*|text()"/>
 </sch:report>
 </xsl:when>
 <xsl:whentest="self::assert">
 <sch:assert>
 <xsl:for-eachselect="@*">
 <xsl:attributename="{./name()}">
 <xsl:value-ofselect="normalize-space(.)"/>
 </xsl:attribute>
 </xsl:for-each>
 <xsl:apply-templatesselect="*|text()"/>
 </sch:assert>
 </xsl:when>
 <xsl:otherwise>
 <xsl:copy-ofselect="."copy-namespaces="no"/>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:template>

 <xsl:templatematch="annotation[@type='schematron']/*/*">
 <xsl:copy-ofselect="."copy-namespaces="no"/>
 </xsl:template>

 <xsl:templatematch="text()[ancestor::annotation[@type='schematron']]">
 <xsl:value-ofselect="normalize-space(.)"/>
 </xsl:template>

<!-- =================== -->
<!-- ATTRIBUTE TEMPLATES -->
<!-- =================== -->

 <xsl:templatematch="attributeDeclaration[@mode='#REQUIRED']">
 <xsl:paramname="attribute"/>
 <sch:rulecontext="{@element}">
 <sch:asserttest="{$attribute}">
 <xsl:value-ofselect="$attribute"/>
 <xsl:text> is a required attribute for </xsl:text>
 <xsl:value-ofselect="('&lt;', @element, '&gt;')"/>
 </sch:assert>
 </sch:rule>
 </xsl:template>

 <xsl:templatematch="attributeDeclaration[@mode='#FIXED']">
 <xsl:paramname="attribute"/>
 <sch:rulecontext="{concat(@element, '/', $attribute)}">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:text>. = '</xsl:text>
 <xsl:value-ofselect="@defaultValue"/>
 <xsl:text>'</xsl:text>
 </xsl:attribute>
 <xsl:value-ofselect="$attribute"/>
 <xsl:text> is a fixed attribute for </xsl:text>
 <xsl:value-ofselect="concat('&lt;', @element, '&gt;')"/>
 <xsl:text> and must equal "</xsl:text>
 <xsl:value-ofselect="@defaultValue"/>
 <xsl:text>"</xsl:text>
 </sch:assert>
 </sch:rule>
 </xsl:template>

 <xsl:templatematch="attributeDeclaration[starts-with(@type, '(') and @mode!='#FIXED']">
 <xsl:paramname="attribute"/>
 <sch:rulecontext="{concat(@element, '/', $attribute)}">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:variablename="values">
 <xsl:for-each-groupselect="tokenize(translate(@type, '()', ''), '\|')"group-by=".">
 <xsl:text>. ='</xsl:text>
 <xsl:value-ofselect="current-grouping-key()"/>
 <xsl:text>' or </xsl:text>
 </xsl:for-each-group>
 </xsl:variable>
 <xsl:value-of
select="string-join((tokenize($values, 'or ')[position() != last()]), 'or ')"/>
 </xsl:attribute>
 <xsl:text>The attribute </xsl:text>
 <xsl:value-ofselect="$attribute"/>
 <xsl:text> can only equal: </xsl:text>
 <xsl:value-of
select="string-join(
 ( tokenize(
 translate(
 string-join(
 ( tokenize(@type, '\|') ), 
 ', '
 ), '()', ''
 ), ','
 )[position() != last()]
 ), ','
 )"/>
 <xsl:text> or</xsl:text>
 <xsl:value-of
select="tokenize(translate(string-join((tokenize(@type, '\|')), ', '), '()', ''), ',')[last()]"/>
 <xsl:text> for the element </xsl:text>
 <xsl:value-ofselect="concat('&lt;', @element, '&gt;')"/>
 </sch:assert>
 </sch:rule>
 </xsl:template>



<!-- ================= -->
<!-- ELEMENT TEMPLATES -->
<!-- ================= -->

<!-- ============================== -->
<!-- Make allowed attributes report-->
<!-- ============================== -->
 <xsl:templatematch="attributes"mode="element">
 <xsl:paramname="element"/>
 <xsl:paramname="e-name"/>
 <xsl:choose>
 <xsl:whentest="attribute[attributeDeclaration/@element=$e-name]">
 <xsl:variablename="allowed-test">
 <xsl:text>@* except (</xsl:text>
 <xsl:variablename="allowed">
 <xsl:for-each-groupselect="attribute[attributeDeclaration/@element=$e-name]"
group-by="@name">
 <xsl:value-ofselect="concat('@', current-grouping-key())"/>
 <xsl:text> | </xsl:text>
 </xsl:for-each-group>
 <xsl:text>)</xsl:text>
 </xsl:variable>
 <xsl:value-ofselect="replace($allowed, ' \| \)', ')')"/>
 </xsl:variable>
 <sch:report>
 <xsl:attributename="test"select="$allowed-test"/>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot contain the following attributes: </xsl:text>
 <value-ofselect="{concat('(', $allowed-test, ')/name()')}"/>
 <xsl:text>.</xsl:text>
 </sch:report>
 </xsl:when>
 <xsl:otherwise>
 <sch:reporttest="@*"><xsl:value-ofselect="$element"/> must not contain any
 attributes.</sch:report>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:template>


<!-- ============================ -->
<!-- Make allowed elements report -->
<!-- ============================ -->
 <xsl:templatematch="@minified">
 <xsl:paramname="element"tunnel="yes"/>
 <xsl:iftest="not(contains(., '#PCDATA'))">
 <sch:reporttest="child::text()[normalize-space()]">
 <xsl:value-ofselect="$element"/>
 <xsl:text> should not contain #PCDATA</xsl:text>
 </sch:report>
 </xsl:if>
 <xsl:iftest=".='EMPTY'">
 <sch:reporttest="*">
 <xsl:value-ofselect="$element"/>
 <xsl:text> should be empty</xsl:text>
 </sch:report>
 </xsl:if>
 <xsl:iftest=".!='EMPTY' and not(starts-with(., '(#PCDATA)'))">
 <sch:report>
 <xsl:variablename="allowed-test">
 <xsl:text>* except (</xsl:text>
 <xsl:value-of
select="replace(string-join((tokenize(translate(translate(substring-after(., '('), '|,', ' '), '?()*+', ''), '\s+')), ' | '), '#PCDATA', 'text()')"/>
 <xsl:text>)</xsl:text>
 </xsl:variable>
 <xsl:attributename="test"select="$allowed-test"/>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot contain the following elements: </xsl:text>
 <value-ofselect="{concat('(', $allowed-test, ')/name()')}"/>
 </sch:report>

<!-- ============================ -->
<!-- Make element ordering report -->
<!-- ============================ -->
 <xsl:iftest="not(ends-with(., '*')) and contains(., ',')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:variablename="order-test">
 <xsl:call-templatename="ordering">
 <xsl:with-paramname="str"select="substring-after(., '(')"/>
 </xsl:call-template>
 </xsl:variable>
 <xsl:value-of
select="string-join((tokenize($order-test, ' or ')[position() != last()]), ' or ')"/>
 </xsl:attribute>
 <xsl:text>Child elements of </xsl:text>
 <xsl:value-ofselect="$element"/>
 <xsl:text> are out of order. <!--The correct order is: </xsl:text><xsl:value-of select="replace(replace(replace(replace(replace(., '\|', ' or '), ',', ', then: '), '\*', '[0 or more]'), '\+', '[1 or more]'), '\?', '[0 or 1]')"/>-->Element model: </xsl:text>
 <xsl:value-ofselect="replace(replace(., ',', ', '), '\|', ' | ')"/>
 </sch:report>
 </xsl:if>
 </xsl:if>
 </xsl:template>

<!-- ================================= -->
<!-- Make model assertions and reports -->
<!-- ================================= -->
 <xsl:templatename="model-entities">
 <xsl:paramname="str"/>
 <xsl:paramname="output"/>
 <xsl:choose>
 <xsl:whentest="$str">
 <xsl:choose>

<!-- =============================== -->
<!-- Handle parenthetical statements -->
<!-- =============================== -->
 <xsl:whentest="starts-with($str, '(')">
 <xsl:variablename="inside-paren">
 <xsl:call-templatename="paren-nesting">
 <xsl:with-paramname="str"select="$str"/>
 </xsl:call-template>
 </xsl:variable>
 <xsl:choose>

<!-- ===== Zero or more of any: no tests ===== -->

 <xsl:whentest="ends-with($inside-paren, '*')">
 <xsl:call-templatename="model-entities">
 <xsl:with-paramname="str"
select="substring-after(substring($str, string-length($inside-paren)), ',')"/>
 <xsl:with-paramname="output">
 <xsl:copy-ofselect="$output"/>
 </xsl:with-param>
 </xsl:call-template>
 </xsl:when>

<!-- ===== Either/Or tests ===== -->

 <xsl:whentest="starts-with($inside-paren, '(') and 
 contains(translate($inside-paren, '+?*', ''), ')|') and 
 not(contains($inside-paren, ',('))">
 <xsl:variablename="or"
select="substring-after(substring-after($inside-paren, ')'),'|')"/>
 <xsl:variablename="either">
 <xsl:iftest="contains($inside-paren, ')|')">
 <xsl:value-ofselect="concat(substring-before($inside-paren, ')|'), ')')"/>
 </xsl:if>
 <xsl:iftest="contains($inside-paren, ')*|')">
 <xsl:value-ofselect="concat(substring-before($inside-paren, ')*|'), ')*')"/>
 </xsl:if>
 <xsl:iftest="contains($inside-paren, ')+|')">
 <xsl:value-ofselect="concat(substring-before($inside-paren, ')+|'), ')+')"/>
 </xsl:if>
 <xsl:iftest="contains($inside-paren, ')?|')">
 <xsl:value-ofselect="concat(substring-before($inside-paren, ')?|'), ')?')"/>
 </xsl:if>
 <xsl:value-ofselect="substring($inside-paren, string-length($inside-paren))"/>
 </xsl:variable>
 <xsl:if
test="not(matches(translate($either, '()?,+*', ''), translate($or, '()?,+*', ''))) and not(matches(translate($or, '()?,+*', ''), translate($either, '()?,+*', '')))">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:text>if (</xsl:text>
 <xsl:value-of
select="string-join((tokenize(translate($or, '?+*()', ''), ',')),' or ')"/>
 <xsl:text>) then not(</xsl:text>
 <xsl:value-of
select="string-join((tokenize(translate($either, '?+*()', ''), ',')),' or ')"/>
 <xsl:text>) else not(</xsl:text>
 <xsl:value-of
select="string-join((tokenize(translate($or, '?+*()', ''), ',')),' or ')"/>
 <xsl:text>)</xsl:text>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;', @name,'&gt;')"/>
 <xsl:text> cannot contain both (&lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($either, '?+*()', ''), ',')),'&gt; or &lt;'), '\|')),'&gt; or &lt;')"/>
 <xsl:text>&gt;) and (&lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($or, '?+*()', ''), ',')),'&gt; or &lt;'), '\|')),'&gt; or &lt;')"/>
 <xsl:text>&gt;)</xsl:text>
 </sch:assert>
 </xsl:if>
 <xsl:variablename="element"select="concat('&lt;',@name,'&gt;')"/>
 <xsl:choose>

<!-- ===== No more than one of either side ===== -->

 <xsl:whentest="ends-with($inside-paren, '?')">
 <xsl:for-eachselect="tokenize(translate($or, '()?+*', ''), ',')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',., ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',.,'&gt;')"/>
 </sch:report>
 </xsl:for-each>
 <xsl:for-eachselect="tokenize(translate($either, '()?+*', ''), ',')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',., ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',.,'&gt;')"/>
 </sch:report>
 </xsl:for-each>
 </xsl:when>

<!-- ===== Minimum one of either side ===== -->

 <xsl:whentest="ends-with($inside-paren, '+')">
 <xsl:comment>NO TEST HERE YET</xsl:comment>
 <xsl:comment>
 <xsl:text>Either/Or: </xsl:text>
 <xsl:copy-ofselect="$inside-paren"/>
 </xsl:comment>
 <xsl:comment>
 <xsl:text>Either: </xsl:text>
 <xsl:copy-ofselect="$either"/>
 </xsl:comment>
 <xsl:comment>
 <xsl:text>Or: </xsl:text>
 <xsl:copy-ofselect="$or"/>
 </xsl:comment>
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-of
select="concat('(', string-join((tokenize(translate($either, '?+*()', ''), ',')),' or '), ')')"/>
 <xsl:text> or </xsl:text>
 <xsl:value-of
select="concat('(', string-join((tokenize(translate($or, '?+*()', ''), ',')),' or '), ')')"
 />
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> must contain at least one (&lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($either, '?+*()', ''), ',')),'&gt; or &lt;'), '\|')),'&gt; or &lt;')"/>
 <xsl:text>&gt;) or (&lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($or, '?+*()', ''), ',')),'&gt; or &lt;'), '\|')),'&gt; or &lt;')"/>
 <xsl:text>&gt;)</xsl:text>
 </sch:assert>
 </xsl:when>

<!-- ===== Either side tests ===== -->

 <xsl:otherwise>

<!-- ~~~~~ Either tests ~~~~~ -->

 <xsl:for-each-groupselect="tokenize(translate($either, '()', ''), ',')"
group-by=".">
 <xsl:variablename="entity-name"
select="translate(current-grouping-key(), '+?*~ ', '')"/>
 <xsl:choose>

<!-- No tests -->

 <xsl:whentest="ends-with(current-grouping-key(), '*')"/>

<!-- At least one of either -->

 <xsl:whentest="ends-with(current-grouping-key(), '+')">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="$entity-name"/>
 <xsl:text> or </xsl:text>
 <xsl:choose>
 <xsl:whentest="not(contains($or, ',') or contains($or, '|'))">
 <xsl:iftest="contains($or, '+')">
 <xsl:value-ofselect="translate($or, '+?*~() ', '')"/>
 </xsl:if>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of
select="concat('(', string-join((tokenize(translate($or, '?+*()', ''), ',')),' or '), ')')"
 />
 </xsl:otherwise>
 </xsl:choose>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> must contain at least one </xsl:text>
 <xsl:value-ofselect="concat('&lt;', $entity-name, '&gt;')"/>
 <xsl:text> or &lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($or, '?+*()', ''), ',')),'&gt;/&lt;'), '\|')),'&gt;/&lt;')"/>
 <xsl:text>&gt;</xsl:text>
 </sch:assert>
 </xsl:when>

<!-- No more than one -->

 <xsl:whentest="ends-with(current-grouping-key(), '?')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',$entity-name, ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:report>
 </xsl:when>

<!-- One of either and no more than one -->

 <xsl:otherwise>
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',$entity-name, ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:report>
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="$entity-name"/>
 <xsl:text> or </xsl:text>
 <xsl:choose>
 <xsl:whentest="not(contains($or, ',') or contains($or, '|'))">
 <xsl:if
test="not(contains($or, '?') or contains($or, '+') or contains($or, '*'))">
 <xsl:value-ofselect="translate($or, '~() ', '')"/>
 </xsl:if>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of
select="concat('(', string-join((tokenize(translate($or, '?+*()', ''), ',')),' or '), ')')"
 />
 </xsl:otherwise>
 </xsl:choose>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> must contain at least one </xsl:text>
 <xsl:value-ofselect="concat('&lt;', $entity-name, '&gt;')"/>
 <xsl:text> or &lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($or, '?+*()', ''), ',')),'&gt;/&lt;'), '\|')),'&gt;/&lt;')"/>
 <xsl:text>&gt;</xsl:text>
 </sch:assert>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:for-each-group>

<!-- ~~~~~ Or tests ~~~~~ -->

 <xsl:for-each-groupselect="tokenize(translate($or, '()', ''), ',')"
group-by=".">
 <xsl:variablename="entity-name"
select="translate(current-grouping-key(), '+?*~ ', '')"/>
 <xsl:choose>

<!-- No tests -->

 <xsl:whentest="ends-with(current-grouping-key(), '*')"/>

<!-- At least one -->

 <xsl:whentest="ends-with(current-grouping-key(), '+')">
 <xsl:choose>
 <xsl:whentest="not(contains($either, '+') or contains($either, '?'))">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="$entity-name"/>
 <xsl:text> or </xsl:text>
 <xsl:choose>
 <xsl:when
test="not(contains($either, ',') or contains($either, '|'))">
 <xsl:value-ofselect="translate($either, '+?*~() ', '')"/>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of
select="concat('(', string-join((tokenize(translate($either, '?+*()', ''), ',')),' or '), ')')"
 />
 </xsl:otherwise>
 </xsl:choose>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> must contain at least one </xsl:text>
 <xsl:value-ofselect="concat('&lt;', $entity-name, '&gt;')"/>
 <xsl:text> or &lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($either, '?+*()', ''), ',')),'&gt;/&lt;'), '\|')),'&gt;/&lt;')"/>
 <xsl:text>&gt;</xsl:text>
 </sch:assert>
 </xsl:when>
 </xsl:choose>
 </xsl:when>

<!-- No more than one -->

 <xsl:whentest="ends-with(current-grouping-key(), '?')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',$entity-name, ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:report>
 </xsl:when>

<!-- One of either and no more than one -->

 <xsl:otherwise>
 <xsl:choose>
 <xsl:whentest="contains($either, '*')">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="$entity-name"/>
 <xsl:text> or </xsl:text>
 <xsl:choose>
 <xsl:when
test="not(contains($either, ',') or contains($either, '|'))">
 <xsl:value-ofselect="translate($either, '+?*~() ', '')"/>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-of
select="concat('(', string-join((tokenize(translate($either, '?+*()', ''), ',')),' or '), ')')"
 />
 </xsl:otherwise>
 </xsl:choose>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> must contain at least one </xsl:text>
 <xsl:value-ofselect="concat('&lt;', $entity-name, '&gt;')"/>
 <xsl:text> or &lt;</xsl:text>
 <xsl:value-of
select="string-join((tokenize(string-join((tokenize(translate($either, '?+*()', ''), ',')),'&gt;/&lt;'), '\|')),'&gt;/&lt;')"/>
 <xsl:text>&gt;</xsl:text>
 </sch:assert>
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',$entity-name, ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="$element"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:report>
 </xsl:when>
 </xsl:choose>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:for-each-group>
 </xsl:otherwise>
 </xsl:choose>
 <xsl:call-templatename="model-entities">
 <xsl:with-paramname="str"
select="substring-after(substring($str, string-length($inside-paren)), ',')"/>
 <xsl:with-paramname="output">
 <xsl:copy-ofselect="$output"/>
 </xsl:with-param>
 </xsl:call-template>
 </xsl:when>

<!-- ===== Moving on ===== -->

 <xsl:otherwise>
 <xsl:call-templatename="model-entities">
 <xsl:with-paramname="str"
select="substring-after(substring($str, string-length($inside-paren)), ',')"/>
 <xsl:with-paramname="output">
 <xsl:copy-ofselect="$output"/>
 <xsl:call-templatename="model-entities">
 <xsl:with-paramname="str"select="$inside-paren"/>
 </xsl:call-template>
 </xsl:with-param>
 </xsl:call-template>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:when>

<!-- =============== -->
<!-- Text only tests -->
<!-- =============== -->
 <xsl:whentest="starts-with($str, '#PCDATA)')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="'*'"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> may contain only #PCDATA</xsl:text>
 </sch:report>
 <xsl:choose>
 <xsl:whentest="$str = '#PCDATA)*'"/>
 <xsl:whentest="$str = '#PCDATA)'">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="'child::text()[normalize-space()]'"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> must contain #PCDATA</xsl:text>
 </sch:assert>
 </xsl:when>
 </xsl:choose>
 </xsl:when>

<!-- =============== -->
<!-- Handle all else -->
<!-- =============== -->
 <xsl:otherwise>
 <xsl:variablename="entity">
 <xsl:choose>
 <xsl:whentest="contains($str,',')">
 <xsl:value-ofselect="substring-before($str,',')"/>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-ofselect="$str"/>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:variable>
 <xsl:variablename="entity-name"select="translate($entity,'(),*? |+~','')"/>
 <xsl:choose>

<!-- =============== -->
<!-- Either/Or tests -->
<!-- =============== -->
 <xsl:whentest="contains($entity, '|')">
 <xsl:choose>


<!-- ===== Zero or more of any: no tests ===== -->

 <xsl:whentest="ends-with($entity, '*')"/>

<!-- ===== At least one of either ===== -->

 <xsl:whentest="ends-with(translate($entity, ')', ''), '+')">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-of
select="string-join((tokenize(translate($entity, '?+*()', ''), '\|')), ' or ')"
 />
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> must have at least one of: </xsl:text>
 <xsl:value-of
select="string-join((tokenize(translate($entity, '?+*()', ''), '\|')), ' or ')"
 />
 </sch:assert>
 </xsl:when>

<!-- ===== No more than one of either ===== -->

 <xsl:whentest="ends-with(translate($entity, ')', ''), '?')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-of
select="concat('count(',string-join((tokenize(translate($entity, '?+*()', ''), '\|')), ' or '), ') > 1')"
 />
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> cannot have more than one of: </xsl:text>
 <xsl:value-of
select="string-join((tokenize(translate($entity, '?+*()', ''), '\|')), ' or ')"
 />
 </sch:report>
 </xsl:when>

<!-- ===== One of either and any number of either ===== -->

 <xsl:otherwise>
 <sch:assert>
 <xsl:attributename="test">
 <xsl:text>if(</xsl:text>
 <xsl:value-of
select="translate(substring-before($entity, '|'), '(),*? |+~','')"/>
 <xsl:text>) then not(</xsl:text>
 <xsl:value-of
select="translate(substring-after($entity, '|'), '(),*? |+~','')"/>
 <xsl:text>) else not(</xsl:text>
 <xsl:value-of
select="translate(substring-before($entity, '|'), '(),*? |+~','')"/>
 <xsl:text>)</xsl:text>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> cannot have both </xsl:text>
 <xsl:value-of
select="concat('&lt;',translate(substring-before($entity, '|'), '(),*? |+~',''),'&gt;')"/>
 <xsl:text> and </xsl:text>
 <xsl:value-of
select="concat('&lt;',translate(substring-after($entity, '|'), '(),*? |+~',''),'&gt;')"
 />
 </sch:assert>
 <xsl:iftest="not(contains($entity, '*'))">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-of
select="translate(substring-before($entity, '|'), '(),*? |+~','')"/>
 <xsl:text> or </xsl:text>
 <xsl:value-of
select="translate(substring-after($entity, '|'), '(),*? |+~','')"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> must have one </xsl:text>
 <xsl:value-of
select="concat('&lt;',translate(substring-before($entity, '|'), '(),*? |+~',''),'&gt;')"/>
 <xsl:text> or one </xsl:text>
 <xsl:value-of
select="concat('&lt;',translate(substring-after($entity, '|'), '(),*? |+~',''),'&gt;')"
 />
 </sch:assert>
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-of
select="concat('count(', translate(substring-before($entity, '|'), '(),*? |+~',''), ') > 1')"/>
 <xsl:text> or </xsl:text>
 <xsl:value-of
select="concat('count(', translate(substring-after($entity, '|'), '(),*? |+~',''), ') > 1')"
 />
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-of
select="concat('&lt;',translate(substring-before($entity, '|'), '(),*? |+~',''),'&gt;')"/>
 <xsl:text> or more than one </xsl:text>
 <xsl:value-of
select="concat('&lt;',translate(substring-after($entity, '|'), '(),*? |+~',''),'&gt;')"
 />
 </sch:report>
 </xsl:if>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:when>

<!-- ================ -->
<!-- Individual tests -->
<!-- ================ -->
 <xsl:otherwise>
 <xsl:call-templatename="model-entities">
 <xsl:with-paramname="str"select="substring-after($str,',')"/>
 <xsl:with-paramname="output">
 <xsl:copy-ofselect="$output"/>
 <xsl:choose>

<!-- ===== Zero or more: no tests ===== -->

 <xsl:whentest="ends-with(translate($entity, ')', ''), '*')"/>


<!-- ===== At least one ===== -->

 <xsl:whentest="ends-with(translate($entity, ')', ''), '+')">
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="$entity-name"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> must have at least one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:assert>
 </xsl:when>

<!-- ===== Zero or one ===== -->

 <xsl:whentest="ends-with(translate($entity, ')', ''), '?')">
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',$entity-name, ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:report>
 </xsl:when>

<!-- ===== One and only one ===== -->

 <xsl:otherwise>
 <sch:assert>
 <xsl:attributename="test">
 <xsl:value-ofselect="$entity-name"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> must have one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:assert>
 <sch:report>
 <xsl:attributename="test">
 <xsl:value-ofselect="concat('count(',$entity-name, ') > 1')"/>
 </xsl:attribute>
 <xsl:value-ofselect="concat('&lt;',@name,'&gt;')"/>
 <xsl:text> cannot have more than one </xsl:text>
 <xsl:value-ofselect="concat('&lt;',$entity-name,'&gt;')"/>
 </sch:report>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:with-param>
 </xsl:call-template>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:when>
 <xsl:otherwise>
 <xsl:copy-ofselect="$output"/>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:template>

 <xsl:templatename="ordering">
 <xsl:paramname="str"/>
 <xsl:paramname="output"/>
 <xsl:choose>
 <xsl:whentest="contains($str, ',')">
 <xsl:variablename="entity">
 <xsl:choose>
 <xsl:whentest="contains($str,',')">
 <xsl:value-ofselect="substring-before($str,',')"/>
 </xsl:when>
 <xsl:otherwise>
 <xsl:value-ofselect="$str"/>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:variable>
 <xsl:choose>
 <xsl:whentest="contains($entity, '|')">
 <xsl:call-templatename="ordering">
 <xsl:with-paramname="str"select="substring-after($str,',')"/>
 <xsl:with-paramname="output">
 <xsl:copy-ofselect="$output"/>
 <xsl:for-each-groupselect="tokenize($entity, '\|')"group-by=".">
 <xsl:variablename="entity-name"
select="translate(current-grouping-key(),'(),*? |+~','')"/>
 <xsl:value-ofselect="concat($entity-name, '[preceding-sibling::')"/>
 <xsl:value-of
select="string-join((tokenize(translate(translate(substring-after($str,','), '+?*()~ ', ''), '|,', ' '), ' ')), ' or preceding-sibling::')"/>
 <xsl:text>] or </xsl:text>
 </xsl:for-each-group>
 </xsl:with-param>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:variablename="entity-name"select="translate($entity,'(),*? |+~','')"/>
 <xsl:call-templatename="ordering">
 <xsl:with-paramname="str"select="substring-after($str,',')"/>
 <xsl:with-paramname="output">
 <xsl:copy-ofselect="$output"/>
 <xsl:value-ofselect="concat($entity-name, '[preceding-sibling::')"/>
 <xsl:value-of
select="string-join((tokenize(translate(translate(substring-after($str,','), '+?*()~ ', ''), '|,', ' '), ' ')), ' or preceding-sibling::')"/>
 <xsl:text>] or </xsl:text>
 </xsl:with-param>
 </xsl:call-template>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:when>
 <xsl:otherwise>
 <xsl:copy-ofselect="$output"/>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:template>

 <xsl:templatename="paren-nesting">
 <xsl:paramname="str"/>
 <xsl:paramname="level"
select="string-length(substring-before($str, ')')) - string-length(translate(substring-before($str, ')'), '(', ''))"/>
 <xsl:choose>
 <xsl:whentest="$level=1">
 <xsl:variablename="content"select="substring-before($str, ')')"/>
 <xsl:value-ofselect="substring-after($content, '(')"/>
 <xsl:value-ofselect="translate(substring($str, string-length($content) + 1, 2), '|,', '~')"
 />
 </xsl:when>
 <xsl:whentest="$level=2">
 <xsl:choose>
 <xsl:whentest="contains(substring-before(substring-after($str, ')'), ')'), '(')">
 <xsl:call-templatename="paren-nesting">
 <xsl:with-paramname="str"select="$str"/>
 <xsl:with-paramname="level"select="$level+1"/>
 </xsl:call-template>
 </xsl:when>
 <xsl:otherwise>
 <xsl:variablename="content"
select="string-join((
 substring-before($str, ')'), 
 substring-before(substring-after($str, ')'), ')')), 
 ')')"/>
 <xsl:value-ofselect="substring-after($content, '(')"/>
 <xsl:value-of
select="translate(substring($str, string-length($content) + 1, 2), '|,', '~')"/>
 </xsl:otherwise>
 </xsl:choose>
 </xsl:when>
 <xsl:whentest="$level=3">
 <xsl:choose>