Mode:

Compact lists

Showing:

Documentation
Parameters
Used by
References
Supersedes
Imported modules
Source
Main stylesheet odd2dtd.xsl
Documentation

Description

TEI stylesheet for making DTD from ODD

This software is dual-licensed: 1. Distributed under a Creative Commons Attribution-ShareAlike 3.0 Unported License http://creativecommons.org/licenses/by-sa/3.0/ 2. http://www.opensource.org/licenses/BSD-2-Clause All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. This software is provided by the copyright holders and contributors "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the copyright holder or contributors be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this software, even if advised of the possibility of such damage.

Author: See AUTHORS

Id: $Id: odd2dtd.xsl 9669 2011-11-07 19:17:54Z rahtz $

Copyright: 2011, TEI Consortium
Imported modules
Stylesheet version 2.0
Template headingNumberSuffix
Namespace No namespace
Supersedes
Import precedence 4
Source
 
<xsl:template name="headingNumberSuffix">
  <xsl:text> </xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template /
Namespace No namespace
Match /
Mode #default
References
Import precedence 4
Source
 
<xsl:template match="/">
  <xsl:choose>
    <xsl:when test="key('SCHEMASPECS',1)">
      <xsl:apply-templates select="key('LISTSCHEMASPECS',$whichSchemaSpec)"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="byModule"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template byModule
Namespace No namespace
Used by
Template
/
References
Import precedence 4
Source
 
<xsl:template name="byModule">
  <xsl:for-each select="key('Modules',1)">
    <xsl:sort order="descending" select="@ident"/>
    <xsl:if test="$verbose='true'">
      <xsl:message>File [
        <xsl:value-of select="@ident"/>]</xsl:message>
    </xsl:if>
    <xsl:call-template name="generateOutput">
      <xsl:with-param name="suffix">.dtd</xsl:with-param>
      <xsl:with-param name="method">text</xsl:with-param>
      <xsl:with-param name="body">
        <xsl:call-template name="dtdComment">
          <xsl:with-param name="text">
            <xsl:text>DTD module </xsl:text>
            <xsl:value-of select="@ident"/>
            <xsl:text>. Generated </xsl:text>
            <xsl:call-template name="showDate"/>
            <xsl:text>. </xsl:text>
            <xsl:call-template name="copyright"/>
            <xsl:call-template name="makeTEIVersion"/>
            <xsl:call-template name="makeDescription"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:choose>
          <xsl:when test="@type='core'">
            <xsl:text><!ENTITY % TEI.extensions.ent '' >
</xsl:text>
            <xsl:text>%TEI.extensions.ent;
</xsl:text>
            <xsl:call-template name="dtdComment">
              <xsl:with-param name="text">
                <xsl:text>list of element names</xsl:text>
              </xsl:with-param>
            </xsl:call-template>
            <xsl:if test="$parameterize='true' and count(key('NSELEMENTS',1))>0">
              <xsl:text><!ENTITY % NS '</xsl:text>
              <xsl:value-of select="$nsPrefix"/>
              <xsl:text>' >
</xsl:text>
            </xsl:if>
            <xsl:if test="$parameterize='true'">
              <xsl:call-template name="NameList"/>
            </xsl:if>
            <xsl:call-template name="datatypeMacros"/>
            <xsl:call-template name="omissability"/>
            <xsl:call-template name="entityModules"/>
            <xsl:call-template name="predeclaredClasses"/>
            <xsl:call-template name="predeclaredMacros"/>
            <xsl:call-template name="normalClasses"/>
            <xsl:call-template name="normalMacros"/>
            <xsl:text>
<!ENTITY % TEI.extensions.dtd '' >
</xsl:text>
            <xsl:text>%TEI.extensions.dtd;
</xsl:text>
            <xsl:apply-templates mode="tangle" select="key('ElementModule',@ident)">
              <xsl:sort select="@ident"/>
            </xsl:apply-templates>
            <xsl:call-template name="elementModules"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:apply-templates mode="tangle" select="key('ElementModule',@ident)">
              <xsl:sort select="@ident"/>
            </xsl:apply-templates>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:with-param>
    </xsl:call-template>
    <xsl:if test="not(@type='core')">
      <xsl:call-template name="generateOutput">
        <xsl:with-param name="suffix">-decl.dtd</xsl:with-param>
        <xsl:with-param name="method">text</xsl:with-param>
        <xsl:with-param name="body">
          <xsl:call-template name="dtdComment">
            <xsl:with-param name="text">
              <xsl:text>TEI P5 entity declaration module for </xsl:text>
              <xsl:value-of select="@ident"/>
              <xsl:text>. Generated </xsl:text>
              <xsl:call-template name="showDate"/>
              <xsl:text>.
</xsl:text>
              <xsl:call-template name="copyright"/>
              <xsl:call-template name="makeTEIVersion"/>
              <xsl:call-template name="makeDescription"/>
            </xsl:with-param>
          </xsl:call-template>
          <xsl:call-template name="datatypeMacros"/>
          <xsl:call-template name="normalClasses"/>
          <xsl:call-template name="normalMacros"/>
          <xsl:call-template name="predeclaredMacros"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:for-each>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template elementModules
Namespace No namespace
Used by
Template
byModule
References
Key
Modules
Import precedence 4
Source
 
<xsl:template name="elementModules">
  <xsl:for-each select="key('Modules',1)">
    <xsl:sort order="descending" select="@ident"/>
    <xsl:if test="not(@type='core')">
      <xsl:text>
<![%TEI.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>;[
	<!ENTITY % file.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text> PUBLIC '-//TEI P5//ELEMENTS </xsl:text>
      <xsl:value-of select="tei:altIdent[@type='FPI']"/>
      <xsl:text>//EN' '</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>.dtd' >
	%file.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>;
	]]>
</xsl:text>
    </xsl:if>
  </xsl:for-each>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template entityModules
Namespace No namespace
Used by
Template
byModule
References
Template
dtdComment
Key
Modules
Import precedence 4
Source
 
<xsl:template name="entityModules">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>Module declarations</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:for-each select="key('Modules',1)">
    <xsl:sort order="descending" select="@ident"/>
    <xsl:if test="not(@type='core')">
      <xsl:text><!ENTITY % TEI.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text> 'IGNORE' >
</xsl:text>
      <xsl:text><![%TEI.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>;[
	<!ENTITY % file.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>-decl PUBLIC '-//TEI P5//ENTITIES </xsl:text>
      <xsl:value-of select="tei:altIdent[@type='FPI']"/>
      <xsl:text>//EN' '</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>-decl.dtd' >
	%file.</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>-decl;
	]]>
</xsl:text>
    </xsl:if>
  </xsl:for-each>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template omissability
Namespace No namespace
Used by
Template
byModule
References
Template
dtdComment
Import precedence 4
Source
 
<xsl:template name="omissability">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>legacy declaration of omissability indicators</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:text><!ENTITY % TEI.XML 'INCLUDE' >
</xsl:text>
  <xsl:text><![%TEI.XML;[
</xsl:text>
  <xsl:text><!ENTITY % om.RO '' >
</xsl:text>
  <xsl:text><!ENTITY % om.RR '' >
</xsl:text>
  <xsl:text>]]>
</xsl:text>
  <xsl:text><!ENTITY % om.RO '- o' >
</xsl:text>
  <xsl:text><!ENTITY % om.RR '- -' >
</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template datatypeMacros
Namespace No namespace
Used by
Template
byModule
References
Template
dtdComment
Key
MacroModule
Import precedence 4
Source
 
<xsl:template name="datatypeMacros">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>Start datatype macro declarations</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:for-each select="key('MacroModule',@ident)">
    <xsl:if test="@type='dt'">
      <xsl:apply-templates mode="tangle" select="."/>
    </xsl:if>
  </xsl:for-each>
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>End of datatype macro declarations</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template predeclaredMacros
Namespace No namespace
Used by
Template
byModule
References
Import precedence 4
Source
 
<xsl:template name="predeclaredMacros">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>Start of pre-declared macros</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:for-each select="key('PredeclareMacrosModule',@ident)">
    <xsl:apply-templates mode="tangle" select="."/>
  </xsl:for-each>
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>End of pre-declared macros</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template normalClasses
Namespace No namespace
Used by
Template
byModule
References
Template
dtdComment
Key
ClassModule
Import precedence 4
Source
 
<xsl:template name="normalClasses">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>Start of classes</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:apply-templates mode="tangle" select="key('ClassModule',@ident)"/>
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>End of classes</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template predeclaredClasses
Namespace No namespace
Used by
Template
byModule
References
Import precedence 4
Source
 
<xsl:template name="predeclaredClasses">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>Start of pre-declared classes</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:for-each select="key('predeclaredClasses',1)">
    <xsl:choose>
      <xsl:when test="@type='atts'">
        <xsl:call-template name="classAtt">
          <xsl:with-param name="declare">false</xsl:with-param>
        </xsl:call-template>
      </xsl:when>
      <xsl:when test="@type='model'">
        <xsl:call-template name="classModel"/>
      </xsl:when>
    </xsl:choose>
  </xsl:for-each>
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>End of pre-declared classes</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template normalMacros
Namespace No namespace
Used by
Template
byModule
References
Import precedence 4
Source
 
<xsl:template name="normalMacros">
  <xsl:if test="@type='core'">
    <xsl:call-template name="dtdComment">
      <xsl:with-param name="text">
        <xsl:text>Global pre-declared macros</xsl:text>
      </xsl:with-param>
    </xsl:call-template>
    <xsl:for-each select="key('PredeclareAllMacros',1)">
      <xsl:text>
<!ENTITY % </xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text> ''</xsl:text>
      <xsl:text>>
</xsl:text>
    </xsl:for-each>
  </xsl:if>
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>Start rest of  macro declarations</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:for-each select="key('MacroModule',@ident)">
    <xsl:if test="not(@type='dt')">
      <xsl:choose>
        <xsl:when test="@predeclare='true'"/>
        <!--	    <xsl:when test="key('PredeclareMacros',@ident)"/>-->
        <xsl:otherwise>
          <xsl:apply-templates mode="tangle" select="."/>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:if>
  </xsl:for-each>
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>End macros</xsl:text>
    </xsl:with-param>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:schemaSpec
Namespace No namespace
Match tei:schemaSpec
Mode #default
References
Parameters
outputDir;
verbose
Templates
generateOutput;
schemaOut
Supersedes
Template
tei:schemaSpec
Import precedence 4
Source
 
<xsl:template match="tei:schemaSpec">
  <xsl:if test="$verbose='true'">
    <xsl:message>schemaSpec
      <xsl:value-of select="@ident"/>
    </xsl:message>
  </xsl:if>
  <xsl:choose>
    <xsl:when test="$outputDir='' or $outputDir='-'">
      <xsl:call-template name="schemaOut"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="generateOutput">
        <xsl:with-param name="suffix">.dtd</xsl:with-param>
        <xsl:with-param name="method">text</xsl:with-param>
        <xsl:with-param name="body">
          <xsl:call-template name="schemaOut"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template schemaOut
Namespace No namespace
Used by
Template
tei:schemaSpec
References
Import precedence 4
Source
 
<xsl:template name="schemaOut">
  <xsl:call-template name="dtdComment">
    <xsl:with-param name="text">
      <xsl:text>DTD Generated </xsl:text>
      <xsl:call-template name="showDate"/>
      <xsl:text>. </xsl:text>
      <xsl:call-template name="copyright"/>
      <xsl:call-template name="makeTEIVersion"/>
      <xsl:call-template name="makeDescription"/>
    </xsl:with-param>
  </xsl:call-template>
  <xsl:choose>
    <xsl:when test="tei:specGrpRef">
      <xsl:variable name="SPECS">
        <tei:schemaSpec>
          <xsl:copy-of select="@*"/>
          <xsl:apply-templates mode="expandSpecs"/>
        </tei:schemaSpec>
      </xsl:variable>
      <xsl:for-each select="$SPECS/tei:schemaSpec">
        <xsl:call-template name="schemaSpecBody"/>
      </xsl:for-each>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="schemaSpecBody"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template schemaSpecBody
Namespace No namespace
Used by
Template
schemaOut
References
Import precedence 4
Source
 
<xsl:template name="schemaSpecBody">
  <xsl:if test="$parameterize='true' and      count(key('NSELEMENTS',1))>0">
    <xsl:text><!ENTITY % NS '</xsl:text>
    <xsl:value-of select="$nsPrefix"/>
    <xsl:text>' >
</xsl:text>
  </xsl:if>
  <xsl:if test="$parameterize='true'">
    <xsl:call-template name="NameList"/>
  </xsl:if>
  <xsl:text>
<!-- start datatypes -->
</xsl:text>
  <xsl:apply-templates mode="tangle" select="tei:macroSpec[@type='dt']"/>
  <xsl:text>
<!-- end datatypes -->
</xsl:text>
  <xsl:if test="tei:classSpec[@predeclare='true']">
    <xsl:text>
<!--predeclared classes -->
</xsl:text>
    <xsl:for-each select="tei:classSpec[@predeclare='true']">
      <xsl:choose>
        <xsl:when test="@type='atts'">
          <xsl:call-template name="classAtt">
            <xsl:with-param name="declare">true</xsl:with-param>
          </xsl:call-template>
        </xsl:when>
        <xsl:when test="@type='model' and $parameterize='false'">
          <xsl:call-template name="classModel">
            <xsl:with-param name="declare">true</xsl:with-param>
          </xsl:call-template>
        </xsl:when>
      </xsl:choose>
    </xsl:for-each>
    <xsl:text>
<!--end of predeclared classes -->
</xsl:text>
    <xsl:apply-templates mode="tangle" select="tei:classSpec"/>
  </xsl:if>
  <xsl:text>
<!-- start predeclared patterns -->
</xsl:text>
  <xsl:for-each select="tei:macroSpec">
    <xsl:if test="@predeclare='true'">
      <xsl:apply-templates mode="tangle" select="."/>
    </xsl:if>
  </xsl:for-each>
  <xsl:text>
<!-- end predeclared patterns -->
</xsl:text>
  <xsl:text>
<!-- start rest of patterns -->
</xsl:text>
  <xsl:for-each select="tei:macroSpec">
    <xsl:choose>
      <xsl:when test="@predeclare='true'"/>
      <xsl:when test="@type='dt'"/>
      <xsl:otherwise>
        <xsl:apply-templates mode="tangle" select="."/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:for-each>
  <xsl:text>
<!-- end patterns -->
</xsl:text>
  <xsl:if test="not(tei:classSpec[@predeclare='true'])">
    <xsl:text>
<!-- start classes -->
</xsl:text>
    <xsl:apply-templates mode="tangle" select="tei:classSpec[@type='atts']"/>
    <xsl:apply-templates mode="tangle" select="tei:classSpec[@type='model']"/>
    <xsl:text>
<!-- stop classes -->
</xsl:text>
  </xsl:if>
  <xsl:text>
<!-- start elements -->
</xsl:text>
  <xsl:apply-templates mode="tangle" select="tei:elementSpec">
    <xsl:sort select="@ident"/>
  </xsl:apply-templates>
  <xsl:text>
<!-- end elements -->
</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpec[@xml:id='TEIGIS']tangle
Namespace No namespace
Match tei:macroSpec[@xml:id='TEIGIS']
Mode tangle
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec[@xml:id='TEIGIS']" mode="tangle"/>
Stylesheet location odd2dtd.xsl
Template NameList
Namespace No namespace
Used by
References
Import precedence 4
Source
 
<xsl:template name="NameList">
  <xsl:choose>
    <xsl:when test="self::tei:schemaSpec">
      <xsl:for-each select="tei:elementSpec">
        <xsl:sort select="@ident"/>
        <xsl:call-template name="declareAnElement"/>
      </xsl:for-each>
    </xsl:when>
    <xsl:otherwise>
      <xsl:for-each select="key('ELEMENTDOCS',1)">
        <xsl:sort select="@ident"/>
        <xsl:call-template name="declareAnElement"/>
      </xsl:for-each>
    </xsl:otherwise>
  </xsl:choose>
  <!-- walk over all the elementSpec elements and make list of 
	 elements -->
</xsl:template>
Stylesheet location odd2dtd.xsl
Template declareAnElement
Namespace No namespace
Used by
Template
NameList
References
Variable
parameterize
Import precedence 4
Source
 
<xsl:template name="declareAnElement">
  <xsl:if test="not(starts-with(@ident,'%'))">
    <xsl:text><!ENTITY % n.</xsl:text>
    <xsl:value-of select="@ident"/>
    <xsl:text> "</xsl:text>
    <xsl:if test="$parameterize='true' and (@ns)">
      <xsl:text>%NS;</xsl:text>
    </xsl:if>
    <xsl:choose>
      <xsl:when test="tei:altIdent=@ident">
        <xsl:value-of select="@ident"/>
      </xsl:when>
      <xsl:when test="tei:altIdent">
        <xsl:value-of select="tei:altIdent"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:value-of select="@ident"/>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:text>">
</xsl:text>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template linkStyle
Namespace No namespace
Supersedes
Template
linkStyle
Import precedence 4
Source
 
<xsl:template name="linkStyle"/>
Stylesheet location odd2dtd.xsl
Template makeAnchor
Namespace No namespace
Used by
Template
tei:index
Parameters
QName Namespace
name No namespace
Import precedence 4
Source
 
<xsl:template name="makeAnchor">
  <xsl:param name="name"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:element[rng:anyName]
Namespace No namespace
Match rng:element[rng:anyName]
Mode #default
Import precedence 4
Source
 
<xsl:template match="rng:element[rng:anyName]">
  <xsl:text>#PCDATA</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:zeroOrMore
Namespace No namespace
Match rng:zeroOrMore
Mode #default
References
Supersedes
Template
rng:zeroOrMore
Import precedence 4
Source
 
<xsl:template match="rng:zeroOrMore">
  <xsl:variable name="body">
    <xsl:call-template name="content">
      <xsl:with-param name="sep" select="','"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:if test="not($body='')">
    <xsl:call-template name="checkStart"/>
    <xsl:value-of select="$body"/>
    <xsl:text>*</xsl:text>
    <xsl:call-template name="checkEnd"/>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:oneOrMore
Namespace No namespace
Match rng:oneOrMore
Mode #default
References
Import precedence 4
Source
 
<xsl:template match="rng:oneOrMore">
  <xsl:variable name="body">
    <xsl:call-template name="content">
      <xsl:with-param name="sep" select="','"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:if test="not($body='')">
    <xsl:call-template name="checkStart"/>
    <xsl:value-of select="$body"/>
    <xsl:text>+</xsl:text>
    <xsl:call-template name="checkEnd"/>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:optional
Namespace No namespace
Match rng:optional
Mode #default
References
Import precedence 4
Source
 
<xsl:template match="rng:optional">
  <xsl:variable name="body">
    <xsl:call-template name="content">
      <xsl:with-param name="sep" select="','"/>
    </xsl:call-template>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$body=''">
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="checkStart"/>
      <xsl:value-of select="$body"/>
      <xsl:text>?</xsl:text>
      <xsl:call-template name="checkEnd"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:choice
Namespace No namespace
Match rng:choice
Mode #default
References
Supersedes
Template
rng:choice
Import precedence 4
Source
 
<xsl:template match="rng:choice">
  <xsl:call-template name="checkStart"/>
  <xsl:choose>
    <xsl:when test="rng:value and ancestor::tei:elementSpec">
      <xsl:text>(#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:when test="rng:value">
      <xsl:text> (</xsl:text>
      <xsl:for-each select="rng:value">
        <xsl:value-of select="."/>
        <xsl:if test="following-sibling::rng:value">
          <xsl:text>|
</xsl:text>
        </xsl:if>
      </xsl:for-each>)</xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="content">
        <xsl:with-param name="sep" select="' |
 '"/>
      </xsl:call-template>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:call-template name="checkEnd"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:group|rng:mixed
Namespace No namespace
Match rng:group|rng:mixed
Mode #default
References
Template
content
Import precedence 4
Source
 
<xsl:template match="rng:group|rng:mixed">
  <xsl:call-template name="content">
    <xsl:with-param name="sep" select="','"/>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:interleave
Namespace No namespace
Match rng:interleave
Mode #default
References
Template
content
Import precedence 4
Source
 
<xsl:template match="rng:interleave">
  <xsl:call-template name="content">
    <xsl:with-param name="sep" select="','"/>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template content
Namespace No namespace
Used by
References
Variable
parameterize
Keys
CLASSES;
ELEMENTS;
MACROS
Template
checkClass
Parameters
QName Namespace
sep No namespace
Import precedence 4
Source
 
<xsl:template name="content">
  <xsl:param name="sep"/>
  <xsl:variable name="parent" select="local-name(..)"/>
  <xsl:variable name="contentbody">
    <xsl:variable name="members">
      <M>
        <xsl:for-each select="rng:*|processing-instruction()">
          <xsl:variable name="F">
            <xsl:choose>
              <xsl:when test="self::processing-instruction()">
                <xsl:apply-templates select="."/>
              </xsl:when>
              <xsl:when test="self::rng:ref and $parameterize='false'">
                <xsl:choose>
                  <xsl:when test="key('CLASSES',@name)">
                    <xsl:variable name="exists">
                      <xsl:call-template name="checkClass">
                        <xsl:with-param name="id" select="@name"/>
                      </xsl:call-template>
                    </xsl:variable>
                    <xsl:choose>
                      <xsl:when test="$exists=''">
                        <xsl:text>_DUMMY_</xsl:text>
                        <xsl:value-of select="@name"/>
                      </xsl:when>
                      <xsl:otherwise>
                        <xsl:apply-templates select="."/>
                      </xsl:otherwise>
                    </xsl:choose>
                  </xsl:when>
                  <xsl:when test="key('CLASSES',substring-before(@name,'_'))">
                    <xsl:variable name="exists">
                      <xsl:call-template name="checkClass">
                        <xsl:with-param name="id" select="substring-before(@name,'_')"/>
                      </xsl:call-template>
                    </xsl:variable>
                    <xsl:choose>
                      <xsl:when test="$exists=''">
                        <xsl:text>_DUMMY_</xsl:text>
                        <xsl:value-of select="@name"/>
                      </xsl:when>
                      <xsl:otherwise>
                        <xsl:apply-templates select="."/>
                      </xsl:otherwise>
                    </xsl:choose>
                  </xsl:when>
                  <xsl:when test="key('MACROS',@name)">
                    <xsl:apply-templates select="."/>
                  </xsl:when>
                  <xsl:when test="key('ELEMENTS',@name)">
                    <xsl:apply-templates select="."/>
                  </xsl:when>
                </xsl:choose>
              </xsl:when>
              <xsl:otherwise>
                <xsl:apply-templates select="."/>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:variable>
          <xsl:if test="not($F='')">
            <N>
              <xsl:value-of select="$F"/>
            </N>
          </xsl:if>
        </xsl:for-each>
      </M>
    </xsl:variable>
    <xsl:for-each select="$members/M">
      <xsl:choose>
        <xsl:when test="starts-with(N[1],'(') and count(N)=1"/>
        <xsl:when test="$parent='content' and count(N)=1 and starts-with(N[1],'%macro.')"/>
        <xsl:when test="$parent='content' and count(N)=1">
          <xsl:text>(</xsl:text>
        </xsl:when>
        <xsl:when test="count(N)=1 and starts-with(N,'%')">
          <xsl:text>(</xsl:text>
        </xsl:when>
        <xsl:when test="count(N)>1">
          <xsl:text>(</xsl:text>
        </xsl:when>
      </xsl:choose>
      <xsl:for-each select="N">
        <xsl:choose>
          <xsl:when test="starts-with(.,'_DUMMY_') and .=preceding-sibling::N[1]"/>
          <xsl:otherwise>
            <xsl:value-of select="."/>
            <xsl:choose>
              <xsl:when test="self::N[1]='|
'"/>
              <xsl:when test="self::N[1]='('"/>
              <xsl:when test="self::N[1]=')' and position() < last()">
                <xsl:value-of select="$sep"/>
              </xsl:when>
              <xsl:when test="following-sibling::N[1]='('"/>
              <xsl:when test="following-sibling::N[1]=')'"/>
              <xsl:when test="following-sibling::N[1]='|
'"/>
              <xsl:when test="position() < last()">
                <xsl:value-of select="$sep"/>
              </xsl:when>
            </xsl:choose>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:for-each>
      <xsl:choose>
        <xsl:when test="starts-with(N[1],'(') and count(N)=1"/>
        <xsl:when test="$parent='content' and count(N)=1 and starts-with(N[1],'%macro.')"/>
        <xsl:when test="$parent='content' and count(N)=1">
          <xsl:text>)</xsl:text>
        </xsl:when>
        <xsl:when test="count(N)=1 and starts-with(N,'%')">
          <xsl:text>)</xsl:text>
        </xsl:when>
        <xsl:when test="count(N)>1">
          <xsl:text>)</xsl:text>
        </xsl:when>
      </xsl:choose>
    </xsl:for-each>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$contentbody=''"/>
    <xsl:when test="$contentbody='()'"/>
    <!-- some special cases of known evil -->
    <xsl:when test="$contentbody='(#PCDATA |  #PCDATA)'">
      <xsl:text>(#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:when test="contains($contentbody,'#PCDATA') and contains($contentbody,'%macro.anyXML;')">
      <xsl:text>(#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:when test="contains($contentbody, '| ()')">
      <xsl:value-of select="substring-before($contentbody,'| ()')"/>
      <xsl:value-of select="substring-after($contentbody,'| ()')"/>
    </xsl:when>
    <xsl:when test="contains($contentbody, ',)')">
      <xsl:value-of select="substring-before($contentbody,',)')"/>
      <xsl:text>)</xsl:text>
      <xsl:value-of select="substring-after($contentbody,',)')"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$contentbody"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:datatype
Namespace No namespace
Match tei:datatype
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:datatype">
  <xsl:choose>
    <xsl:when test="rng:data/@type='ID'">
      <xsl:text> ID</xsl:text>
    </xsl:when>
    <xsl:when test="rng:data/@type='IDREF'">
      <xsl:text> IDREF</xsl:text>
    </xsl:when>
    <xsl:when test="rng:data/@type='IDREFS'">
      <xsl:text> IDREFS</xsl:text>
    </xsl:when>
    <xsl:when test="rng:data/@type='NMTOKEN'">
      <xsl:text> NMTOKEN</xsl:text>
    </xsl:when>
    <xsl:when test="rng:data/@type='NMTOKENS'">
      <xsl:text> NMTOKENS</xsl:text>
    </xsl:when>
    <xsl:when test="rng:data/@type='boolean'">
      <xsl:text> (true | false) </xsl:text>
    </xsl:when>
    <xsl:when test="rng:ref">
      <xsl:text> %</xsl:text>
      <xsl:value-of select="rng:ref/@name"/>
      <xsl:text>; </xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text> CDATA</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:element
Namespace No namespace
Match rng:element
Mode #default
References
Template
topLevel
Import precedence 4
Source
 
<xsl:template match="rng:element">
  <xsl:choose>
    <xsl:when test="parent::tei:content/parent::tei:macroSpec">
      <xsl:call-template name="topLevel"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="@name"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:empty
Documentation

Description

  
       <xsl:template match="tei:text()"/>
Namespace No namespace
Match rng:empty
Mode #default
Import precedence 4
Source
 
<xsl:template match="rng:empty">
  <xsl:text>EMPTY</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:data
Namespace No namespace
Match rng:data
Mode #default
Import precedence 4
Source
 
<xsl:template match="rng:data">
  <xsl:choose>
    <xsl:when test="parent::tei:content/parent::tei:macroSpec[@type='dt']">
      <xsl:text> CDATA </xsl:text>
    </xsl:when>
    <xsl:when test="parent::tei:content">
      <xsl:text> (#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:when test="@type='ID'">ID</xsl:when>
    <xsl:when test="@type='IDREF'">IDREF</xsl:when>
    <xsl:when test="@type='IDREFS'">IDREFS</xsl:when>
    <xsl:otherwise>CDATA</xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:text
Namespace No namespace
Match rng:text
Mode #default
References
Template
topLevel
Import precedence 4
Source
 
<xsl:template match="rng:text">
  <xsl:choose>
    <xsl:when test="parent::tei:content/parent::tei:macroSpec">
      <xsl:call-template name="topLevel"/>
    </xsl:when>
    <xsl:when test="parent::tei:content">
      <xsl:text> (#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text> #PCDATA</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpec[@type='dt']/tei:content/rng:text
Namespace No namespace
Match tei:macroSpec[@type='dt']/tei:content/rng:text
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:text">
  <xsl:text> CDATA</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpec[@type='dt']/tei:content/rng:data
Namespace No namespace
Match tei:macroSpec[@type='dt']/tei:content/rng:data
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:data">
  <xsl:text> CDATA</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpec[@type='epe']/tei:content/rng:text
Namespace No namespace
Match tei:macroSpec[@type='epe']/tei:content/rng:text
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec[@type='epe']/tei:content/rng:text">
  <xsl:text>CDATA</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpec[@type='dt']/tei:content/rng:list
Namespace No namespace
Match tei:macroSpec[@type='dt']/tei:content/rng:list
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:list">
  <xsl:text> CDATA</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpec[@type='dt']/tei:content/rng:choice
Namespace No namespace
Match tei:macroSpec[@type='dt']/tei:content/rng:choice
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec[@type='dt']/tei:content/rng:choice">
  <xsl:choose>
    <xsl:when test="rng:value">
      <xsl:text>(</xsl:text>
      <xsl:for-each select="rng:value">
        <xsl:value-of select="."/>
        <xsl:if test="following-sibling::rng:value">|</xsl:if>
      </xsl:for-each>
      <xsl:if test="rng:data/@type='boolean'">
        <xsl:text> | true | false</xsl:text>
      </xsl:if>
      <xsl:text>)</xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text> CDATA</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:textsimple
Namespace No namespace
Match rng:text
Mode simple
Import precedence 4
Source
 
<xsl:template match="rng:text" mode="simple">
  <xsl:choose>
    <xsl:when test="parent::tei:content/parent::tei:macroSpec[@type='dt']">
      <xsl:text> CDATA</xsl:text>
    </xsl:when>
    <xsl:when test="parent::tei:content/parent::tei:macroSpec[@type='pe']">
      <xsl:text>#PCDATA</xsl:text>
    </xsl:when>
    <xsl:when test="parent::tei:content and not(following-sibling::rng:*) and not (preceding-sibling::rng:*)">
      <xsl:text>(#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:when test="parent::tei:content and not(following-sibling::rng:*) and not (preceding-sibling::rng:*)">
      <xsl:text>(#PCDATA)</xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text>#PCDATA</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template processing-instruction()[name(.)='teidtd']
Namespace No namespace
Match processing-instruction()[name(.)='teidtd']
Mode #default
Import precedence 4
Source
 
<xsl:template match="processing-instruction()[name(.)='teidtd']">
  <xsl:value-of select="."/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template processing-instruction()[name(.)='teidtd']tangle
Namespace No namespace
Match processing-instruction()[name(.)='teidtd']
Mode tangle
Import precedence 4
Source
 
<xsl:template match="processing-instruction()[name(.)='teidtd']" mode="tangle">
  <xsl:value-of select="."/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:ref
Namespace No namespace
Match rng:ref
Mode #default
References
Templates
refbody;
topLevel
Key
MACROS
Supersedes
Template
rng:ref
Import precedence 4
Source
 
<xsl:template match="rng:ref">
  <xsl:choose>
    <xsl:when test="parent::tei:content/parent::tei:macroSpec">
      <xsl:call-template name="topLevel"/>
    </xsl:when>
    <xsl:when test="count(parent::tei:content/rng:*)>1">
      <xsl:choose>
        <xsl:when test="not(preceding-sibling::rng:*)">
          <xsl:text>(</xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>,</xsl:text>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:call-template name="refbody"/>
      <xsl:if test="not(following-sibling::rng:*)">
        <xsl:text>)</xsl:text>
      </xsl:if>
    </xsl:when>
    <xsl:when test="key('MACROS',@name)">
      <xsl:call-template name="refbody"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:if test="parent::tei:content">(</xsl:if>
      <xsl:call-template name="refbody"/>
      <xsl:if test="parent::tei:content">)</xsl:if>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:refsimple
Namespace No namespace
Match rng:ref
Mode simple
References
Template
refbody
Import precedence 4
Source
 
<xsl:template match="rng:ref" mode="simple">
  <xsl:call-template name="refbody"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template refbody
Namespace No namespace
Used by
Templates
rng:ref;
rng:refsimple
References
Variable
parameterize
Keys
CLASSES;
ELEMENTS;
MACROS
Template
checkClass
Import precedence 4
Source
 
<xsl:template name="refbody">
  <xsl:variable name="R">
    <xsl:choose>
      <xsl:when test="$parameterize='false'">
        <xsl:choose>
          <xsl:when test="key('CLASSES',@name)">
            <xsl:variable name="exists">
              <xsl:call-template name="checkClass">
                <xsl:with-param name="id" select="@name"/>
              </xsl:call-template>
            </xsl:variable>
            <xsl:choose>
              <xsl:when test="$exists=''">
                <xsl:text>_DUMMY_</xsl:text>
                <xsl:value-of select="@name"/>
              </xsl:when>
              <xsl:otherwise>
                <xsl:text>%</xsl:text>
                <xsl:value-of select="@name"/>
                <xsl:text>;</xsl:text>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:when>
          <xsl:when test="key('CLASSES',substring-before(@name,'_'))">
            <xsl:variable name="exists">
              <xsl:call-template name="checkClass">
                <xsl:with-param name="id" select="substring-before(@name,'_')"/>
              </xsl:call-template>
            </xsl:variable>
            <xsl:choose>
              <xsl:when test="$exists=''">
                <xsl:text>_DUMMY_</xsl:text>
                <xsl:value-of select="@name"/>
              </xsl:when>
              <xsl:otherwise>
                <xsl:text>%</xsl:text>
                <xsl:value-of select="@name"/>
                <xsl:text>;</xsl:text>
              </xsl:otherwise>
            </xsl:choose>
          </xsl:when>
          <xsl:when test="key('MACROS',@name)">
            <xsl:text>%</xsl:text>
            <xsl:value-of select="@name"/>
            <xsl:text>;</xsl:text>
          </xsl:when>
          <xsl:when test="key('ELEMENTS',@name)">
            <xsl:for-each select="key('ELEMENTS',@name)">
              <xsl:choose>
                <xsl:when test="tei:altIdent=@ident">
                  <xsl:value-of select="@ident"/>
                </xsl:when>
                <xsl:when test="tei:altIdent">
                  <xsl:value-of select="normalize-space(tei:altIdent)"/>
                </xsl:when>
                <xsl:otherwise>
                  <xsl:value-of select="@ident"/>
                </xsl:otherwise>
              </xsl:choose>
            </xsl:for-each>
          </xsl:when>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="@name='IGNORE' or @name='INCLUDE'">
        <xsl:value-of select="@name"/>
      </xsl:when>
      <xsl:when test="contains(@name, '.')">
        <xsl:text>%</xsl:text>
        <xsl:value-of select="@name"/>
        <xsl:text>;</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>%n.</xsl:text>
        <xsl:value-of select="@name"/>
        <xsl:text>;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:value-of select="$R"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template topLevel
Namespace No namespace
Used by
Import precedence 4
Source
 
<xsl:template name="topLevel">
  <xsl:variable name="unit">
    <xsl:apply-templates mode="simple" select="."/>
  </xsl:variable>
  <xsl:if test="not($unit='')">
    <xsl:if test="preceding-sibling::rng:*">
      <xsl:choose>
        <xsl:when test="preceding-sibling::processing-instruction()"/>
        <xsl:otherwise>
          <xsl:text>|
</xsl:text>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:if>
    <xsl:value-of select="$unit"/>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template rng:elementsimple
Namespace No namespace
Match rng:element
Mode simple
Import precedence 4
Source
 
<xsl:template match="rng:element" mode="simple">
  <xsl:choose>
    <xsl:when test="@name">
      <xsl:value-of select="@name"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text>ANY</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:macroSpectangle
Namespace No namespace
Match tei:macroSpec
Mode tangle
References
Variable
parameterize
Parameter
verbose
Template
macroBody
Key
ElementModule
Supersedes
Import precedence 4
Source
 
<xsl:template match="tei:macroSpec" mode="tangle">
  <xsl:choose>
    <xsl:when test="@depend and $parameterize='true'">
      <xsl:if test="$verbose='true'">
        <xsl:message>Dependency on
          <xsl:value-of select="@depend"/>for
          <xsl:value-of select="@ident"/>
        </xsl:message>
      </xsl:if>
      <xsl:text>
 <![%TEI.</xsl:text>
      <xsl:value-of select="@depend"/>;[
      <xsl:call-template name="macroBody"/>
      <xsl:text>
]]></xsl:text>
    </xsl:when>
    <xsl:when test="@depend and count(key('ElementModule',@depend))=0">
      <xsl:if test="$verbose='true'">
        <xsl:message>Dependency on
          <xsl:value-of select="@depend"/>, but not used in this schema</xsl:message>
      </xsl:if>
    </xsl:when>
    <xsl:otherwise>
      <xsl:call-template name="macroBody"/>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template macroBody
Namespace No namespace
Used by
Import precedence 4
Source
 
<xsl:template name="macroBody">
  <xsl:text>
<!ENTITY </xsl:text>
  <xsl:if test="not(@type) or @type='defaultpe' or @type='pe' or @type='epe' or @type='dt'">
    <xsl:text>%</xsl:text>
  </xsl:if>
  <xsl:text> </xsl:text>
  <xsl:value-of select="@ident"/>
  <xsl:text> '</xsl:text>
  <xsl:for-each select="tei:content">
    <xsl:choose>
      <xsl:when test=".//rng:anyName">
        <xsl:text> ANY</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:apply-templates select="tei:*|rng:*|processing-instruction()"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:for-each>
  <xsl:text>' >
</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:elementSpectangle
Namespace No namespace
Match tei:elementSpec
Mode tangle
References
Parameter
verbose
Template
elementBody
Variable
parameterize
Supersedes
Import precedence 4
Source
 
<xsl:template match="tei:elementSpec" mode="tangle">
  <xsl:if test="$verbose='true'">
    <xsl:message>.... elementSpec
      <xsl:value-of select="@ident"/>
    </xsl:message>
  </xsl:if>
  <xsl:choose>
    <xsl:when test="starts-with(@ident,'%')">
      <xsl:call-template name="elementBody"/>
    </xsl:when>
    <xsl:when test="$parameterize='false'">
      <xsl:call-template name="elementBody"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text>
<!ENTITY % </xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text> 'INCLUDE' >
<![ %</xsl:text>
      <xsl:value-of select="@ident"/>
      <xsl:text>; [
</xsl:text>
      <xsl:call-template name="elementBody"/>
      <xsl:text>
]]>
</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template elementBody
Namespace No namespace
Used by
References
Import precedence 4
Source
 
<xsl:template name="elementBody">
  <xsl:variable name="ename">
    <xsl:choose>
      <xsl:when test="$parameterize='false'">
        <xsl:choose>
          <xsl:when test="@ns='http://www.w3.org/1999/xhtml'">
            <xsl:text>html:</xsl:text>
            <xsl:value-of select="@ident"/>
          </xsl:when>
          <xsl:when test="tei:altIdent=@ident">
            <xsl:value-of select="@ident"/>
          </xsl:when>
          <xsl:when test="tei:altIdent">
            <xsl:value-of select="normalize-space(tei:altIdent)"/>
          </xsl:when>
          <xsl:otherwise>
            <xsl:value-of select="@ident"/>
          </xsl:otherwise>
        </xsl:choose>
      </xsl:when>
      <xsl:when test="starts-with(@ident,'%')">
        <xsl:value-of select="@ident"/>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>%n.</xsl:text>
        <xsl:value-of select="@ident"/>
        <xsl:text>;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:text>
<!--doc:</xsl:text>
  <xsl:call-template name="makeDescription">
    <xsl:with-param name="includeValList">true</xsl:with-param>
    <xsl:with-param name="coded">false</xsl:with-param>
  </xsl:call-template>
  <xsl:text> -->
</xsl:text>
  <xsl:text><!ELEMENT </xsl:text>
  <xsl:value-of select="$ename"/>
  <xsl:if test="$parameterize='true'">
    <xsl:text> %om.RR;</xsl:text>
  </xsl:if>
  <xsl:text> </xsl:text>
  <xsl:variable name="Contents">
    <BLAH>
      <xsl:choose>
        <xsl:when test="tei:content/rng:element[rng:anyName]">
          <xsl:text> (#PCDATA)</xsl:text>
        </xsl:when>
        <xsl:when test="tei:content/rng:element">
          <xsl:text> ANY</xsl:text>
        </xsl:when>
        <xsl:when test="tei:valList[@type='closed']">
          <xsl:text> (#PCDATA)</xsl:text>
        </xsl:when>
        <xsl:when test="tei:content">
          <xsl:apply-templates select="tei:content/*"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text/>
        </xsl:otherwise>
      </xsl:choose>
    </BLAH>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$Contents=''">
      <xsl:text> EMPTY</xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="$Contents"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:text>></xsl:text>
  <xsl:choose>
    <xsl:when test="@ns and @ns=''">
    </xsl:when>
    <xsl:when test="key('LISTSCHEMASPECS',$whichSchemaSpec)/@ns=''">
    </xsl:when>
    <xsl:when test="@ns">
      <xsl:text>
<!ATTLIST </xsl:text>
      <xsl:value-of select="$ename"/>
      <xsl:text> xmlns CDATA "</xsl:text>
      <xsl:value-of select="@ns"/>
      <xsl:text>"</xsl:text>
      <xsl:text>></xsl:text>
    </xsl:when>
    <xsl:when test="key('LISTSCHEMASPECS',$whichSchemaSpec)/@ns">
      <xsl:text>
<!ATTLIST </xsl:text>
      <xsl:value-of select="$ename"/>
      <xsl:text> xmlns CDATA "</xsl:text>
      <xsl:value-of select="ancestor::tei:schemaSpec/@ns"/>
      <xsl:text>"</xsl:text>
      <xsl:text>></xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text>
<!ATTLIST </xsl:text>
      <xsl:value-of select="$ename"/>
      <xsl:text> xmlns CDATA "http://www.tei-c.org/ns/1.0"</xsl:text>
      <xsl:text>></xsl:text>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:variable name="maybeatts">
    <xsl:if test="$parameterize='true' and $autoGlobal='true'">
      <xsl:text>
 %att.global.attributes;</xsl:text>
    </xsl:if>
    <xsl:if test="$parameterize='true'">
      <xsl:apply-templates mode="tangleAtts" select="tei:classes/tei:memberOf"/>
    </xsl:if>
    <xsl:call-template name="attributeList"/>
  </xsl:variable>
  <xsl:if test="string-length($maybeatts) >0">
    <xsl:text>
<!ATTLIST </xsl:text>
    <xsl:value-of select="$ename"/>
    <xsl:value-of select="$maybeatts"/>
    <xsl:text> ></xsl:text>
  </xsl:if>
  <xsl:if test="@ident='TEI' or @ident='teiCorpus'">
    <xsl:text>
<!ATTLIST </xsl:text>
    <xsl:value-of select="$ename"/>
    <xsl:text> xsi:schemaLocation CDATA #IMPLIED
</xsl:text>
    <xsl:text> xmlns:xsi CDATA #FIXED 'http://www.w3.org/2001/XMLSchema-instance'
</xsl:text>
    <xsl:text> ></xsl:text>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template attclasses
Namespace No namespace
Used by
Template
classAtt
References
Key
IDENTS
Import precedence 4
Source
 
<xsl:template name="attclasses">
  <xsl:for-each select="tei:classes/tei:memberOf">
    <xsl:for-each select="key('IDENTS',@key)[1]">
      <xsl:if test="@type='atts'">%
        <xsl:value-of select="@ident"/>
        <xsl:text>.attributes;</xsl:text>
      </xsl:if>
    </xsl:for-each>
  </xsl:for-each>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template classAtt
Namespace No namespace
Used by
References
Parameter
verbose
Variable
parameterize
Templates
attclasses;
attributeList
Parameters
QName Namespace
declare No namespace
Import precedence 4
Source
 
<xsl:template name="classAtt">
  <xsl:param name="declare">true</xsl:param>
  <xsl:if test="$verbose='true'">
    <xsl:message>....
      <xsl:value-of select="@ident"/>.attributes</xsl:message>
  </xsl:if>
  <xsl:variable name="thisclass">
    <xsl:value-of select="@ident"/>
  </xsl:variable>
  <xsl:choose>
    <xsl:when test="$declare='false'">
      <xsl:text>
<!ENTITY % </xsl:text>
      <xsl:value-of select="$thisclass"/>
      <xsl:text>.attributes</xsl:text>
      <xsl:text> ''></xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:choose>
        <xsl:when test="$parameterize='true'">
          <xsl:text>
<!ENTITY % </xsl:text>
          <xsl:value-of select="$thisclass"/>
          <xsl:text>.attributes '</xsl:text>
          <xsl:call-template name="attclasses"/>
          <xsl:call-template name="attributeList"/>
          <xsl:text>'> </xsl:text>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text><!ENTITY % </xsl:text>
          <xsl:value-of select="$thisclass"/>
          <xsl:text>.attributes '</xsl:text>
          <xsl:call-template name="attclasses"/>
          <xsl:call-template name="attributeList"/>
          <xsl:text>'> </xsl:text>
          <xsl:for-each select="tei:attList/tei:attDef">
            <xsl:text>
<!ENTITY % </xsl:text>
            <xsl:value-of select="$thisclass"/>
            <xsl:text>.attribute.</xsl:text>
            <xsl:value-of select="translate(@ident,':','')"/>
            <xsl:text> '</xsl:text>
            <xsl:apply-templates mode="tangle" select="."/>
            <xsl:text>'>
</xsl:text>
          </xsl:for-each>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:classSpectagatts
Namespace No namespace
Match tei:classSpec
Mode tagatts
References
Parameter
verbose
Import precedence 4
Source
 
<xsl:template match="tei:classSpec" mode="tagatts">
  <xsl:if test="@type='atts'">
    <xsl:if test="$verbose='true'">
      <xsl:message>.... added contents of [%
        <xsl:value-of select="@ident"/>.attributes;]</xsl:message>
    </xsl:if>
    <xsl:text>
 %</xsl:text>
    <xsl:value-of select="@ident"/>
    <xsl:text>.attributes;</xsl:text>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:moduleRef[@key]tangle
Namespace No namespace
Match tei:moduleRef[@key]
Mode tangle
References
Parameter
verbose
Key
FILES
Import precedence 4
Source
 
<xsl:template match="tei:moduleRef[@key]" mode="tangle">
  <xsl:if test="$verbose='true'">
    <xsl:message>moduleRef to
      <xsl:value-of select="@key"/>
    </xsl:message>
  </xsl:if>
  <xsl:text>
<!ENTITY %</xsl:text>
  <xsl:text> file.</xsl:text>
  <xsl:value-of select="@key"/>
  <xsl:text> </xsl:text>
  <xsl:text>PUBLIC</xsl:text>
  <xsl:text> '-//TEI P5//</xsl:text>
  <xsl:value-of select="key('FILES',@key)/tei:altIdent[@type='FPI']"/>
  <xsl:text>//EN' '</xsl:text>
  <xsl:value-of select="@key"/>
  <xsl:text>.dtd'</xsl:text>
  <xsl:text> >
</xsl:text>
  <xsl:text>%file.</xsl:text>
  <xsl:value-of select="@key"/>
  <xsl:text>;
</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:classSpectangle
Namespace No namespace
Match tei:classSpec
Mode tangle
References
Parameter
verbose
Templates
classAtt;
classModel
Supersedes
Import precedence 4
Source
 
<xsl:template match="tei:classSpec" mode="tangle">
  <xsl:if test="$verbose='true'">
    <xsl:message>.. classSpec
      <xsl:value-of select="@ident"/>,
      <xsl:value-of select="@type"/>
    </xsl:message>
  </xsl:if>
  <xsl:choose>
    <xsl:when test="@type='atts'">
      <xsl:call-template name="classAtt"/>
    </xsl:when>
    <xsl:when test="@type='model'">
      <xsl:call-template name="classModel"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:classSpecprocess
Namespace No namespace
Match tei:classSpec
Mode process
References
Templates
classAtt;
classModel
Import precedence 4
Source
 
<xsl:template match="tei:classSpec" mode="process">
  <xsl:choose>
    <xsl:when test="@type='atts'">
      <xsl:call-template name="classAtt"/>
    </xsl:when>
    <xsl:when test="@type='model'">
      <xsl:call-template name="classModel"/>
    </xsl:when>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template classModel
Namespace No namespace
Used by
References
Parameters
QName Namespace
declare No namespace
Import precedence 4
Source
 
<xsl:template name="classModel">
  <xsl:param name="declare">false</xsl:param>
  <xsl:call-template name="processClassDefinition">
    <xsl:with-param name="type">
      <xsl:choose>
        <xsl:when test="@generate">
          <xsl:value-of select="@generate"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:text>alternation
	    sequence
	    sequenceOptional
	    sequenceOptionalRepeatable
	    sequenceRepeatable</xsl:text>
        </xsl:otherwise>
      </xsl:choose>
    </xsl:with-param>
    <xsl:with-param name="declare" select="$declare"/>
  </xsl:call-template>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template makeClassDefinition
Namespace No namespace
Used by
References
Supersedes
Parameters
QName Namespace
declare No namespace
type No namespace
Import precedence 4
Source
 
<xsl:template name="makeClassDefinition">
  <xsl:param name="type">alternation</xsl:param>
  <xsl:param name="declare"/>
  <xsl:variable name="IDENT">
    <xsl:value-of select="@ident"/>
    <xsl:choose>
      <xsl:when test="$type='alternation'"/>
      <xsl:otherwise>
        <xsl:text>_</xsl:text>
        <xsl:value-of select="$type"/>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:variable>
  <xsl:if test="$verbose='true'">
    <xsl:message>.... ... generate model
      <xsl:value-of select="$type"/>for
      <xsl:value-of select="@ident"/>
    </xsl:message>
  </xsl:if>
  <xsl:if test="$parameterize='true'">
    <xsl:text>
<!ENTITY % x.</xsl:text>
    <xsl:value-of select="$IDENT"/>
    <xsl:text> "" ></xsl:text>
  </xsl:if>
  <xsl:text>
<!ENTITY % </xsl:text>
  <xsl:value-of select="$IDENT"/>
  <xsl:text> "</xsl:text>
  <xsl:if test="$parameterize='true'">
    <xsl:text>%x.</xsl:text>
    <xsl:value-of select="$IDENT"/>
    <xsl:text>; </xsl:text>
  </xsl:if>
  <xsl:variable name="generate" select="@generate"/>
  <xsl:variable name="members">
    <M>
      <xsl:for-each select="key('CLASSMEMBERS',@ident)">
        <xsl:variable name="N">
          <xsl:choose>
            <xsl:when test="$parameterize='false'">
              <xsl:choose>
                <xsl:when test="key('CLASSES',@ident)">
                  <xsl:variable name="exists">
                    <xsl:call-template name="checkClass">
                      <xsl:with-param name="id" select="@ident"/>
                    </xsl:call-template>
                  </xsl:variable>
                  <xsl:if test="not($exists='')">
                    <xsl:text>%</xsl:text>
                    <xsl:value-of select="@ident"/>
                    <xsl:text>;</xsl:text>
                  </xsl:if>
                </xsl:when>
                <xsl:when test="key('MACROS',@ident)">
                  <xsl:text>%</xsl:text>
                  <xsl:value-of select="@ident"/>
                  <xsl:text>;</xsl:text>
                </xsl:when>
                <xsl:when test="key('ELEMENTS',@ident)">
                  <xsl:choose>
                    <xsl:when test="tei:altIdent=@ident">
                      <xsl:value-of select="@ident"/>
                    </xsl:when>
                    <xsl:when test="tei:altIdent">
                      <xsl:value-of select="normalize-space(tei:altIdent)"/>
                    </xsl:when>
                    <xsl:otherwise>
                      <xsl:value-of select="@ident"/>
                    </xsl:otherwise>
                  </xsl:choose>
                </xsl:when>
              </xsl:choose>
            </xsl:when>
            <xsl:when test="self::tei:elementSpec">
              <xsl:if test="$parameterize='true'">
                <xsl:text>%n.</xsl:text>
              </xsl:if>
              <xsl:value-of select="@ident"/>
              <xsl:if test="$parameterize='true'">
                <xsl:text>;</xsl:text>
              </xsl:if>
            </xsl:when>
            <xsl:when test="self::tei:classSpec">
              <xsl:text>%</xsl:text>
              <xsl:value-of select="@ident"/>
              <xsl:text>;</xsl:text>
            </xsl:when>
            <xsl:otherwise>
              <xsl:value-of select="@ident"/>
            </xsl:otherwise>
          </xsl:choose>
        </xsl:variable>
        <xsl:if test="not($N='')">
          <N>
            <xsl:if test="starts-with($N,'%tei.')">
              <xsl:attribute name="type">class</xsl:attribute>
            </xsl:if>
            <xsl:if test="starts-with($N,'%model.')">
              <xsl:attribute name="type">class</xsl:attribute>
            </xsl:if>
            <xsl:value-of select="$N"/>
          </N>
        </xsl:if>
      </xsl:for-each>
    </M>
  </xsl:variable>
  <xsl:for-each select="$members/M">
    <xsl:call-template name="memberOfClassDefinition">
      <xsl:with-param name="type" select="$type"/>
    </xsl:call-template>
  </xsl:for-each>
  <xsl:text>"> </xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template memberOfClassDefinition
Namespace No namespace
Used by
Parameters
QName Namespace
type No namespace
Import precedence 4
Source
 
<xsl:template name="memberOfClassDefinition">
  <xsl:param name="type"/>
  <!-- does a class model need bracketing if all its members are also classes?
	 <xsl:if test="count(N[@type='class'])=count(N) and count(N) &gt; 2">
	 <xsl:text>(</xsl:text>
	 </xsl:if>
    -->
  <xsl:for-each select="N">
    <xsl:value-of select="."/>
    <xsl:choose>
      <xsl:when test="$type='sequence'">
        <xsl:if test="position() < last()">,</xsl:if>
      </xsl:when>
      <xsl:when test="$type='sequenceOptional'">
        <xsl:text>?</xsl:text>
        <xsl:if test="position() < last()">,</xsl:if>
      </xsl:when>
      <xsl:when test="$type='sequenceRepeatable'">
        <xsl:text>+</xsl:text>
        <xsl:if test="position() < last()">,</xsl:if>
      </xsl:when>
      <xsl:when test="$type='sequenceOptionalRepeatable'">
        <xsl:text>*</xsl:text>
        <xsl:if test="position() < last()">,</xsl:if>
      </xsl:when>
      <xsl:otherwise>
        <xsl:if test="position() < last()">|</xsl:if>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:for-each>
  <!-- see above
	 <xsl:if test="count(N[@type='class'])=count(N) and count(N) &gt; 2">
	 <xsl:text>)</xsl:text>
	 </xsl:if>
    -->
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:commDecltangle
Namespace No namespace
Match tei:commDecl
Mode tangle
Import precedence 4
Source
 
<xsl:template match="tei:commDecl" mode="tangle">
  <xsl:text>
  <!--</xsl:text>
  <xsl:apply-templates/>
  <xsl:text>--></xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template attributeList
Namespace No namespace
Used by
Templates
classAtt;
elementBody
Import precedence 4
Source
 
<xsl:template name="attributeList">
  <xsl:apply-templates mode="tangle" select="tei:attList/tei:*"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:attDeftangle
Namespace No namespace
Match tei:attDef
Mode tangle
References
Variables
nsPrefix;
parameterize
Supersedes
Template
tei:attDeftangle
Import precedence 4
Source
 
<xsl:template match="tei:attDef" mode="tangle">
  <xsl:text>
</xsl:text>
  <xsl:choose>
    <xsl:when test="@ns='http://www.w3.org/XML/1998/namespace'">
      <xsl:text>xml:</xsl:text>
    </xsl:when>
    <xsl:when test="@ns='http://www.w3.org/1999/xlink'">
      <xsl:text>xlink:</xsl:text>
    </xsl:when>
    <xsl:when test="$parameterize='true' and (@ns) and not($nsPrefix='') and not(starts-with(@ident,'xmlns'))">
      <xsl:text>%NS;</xsl:text>
    </xsl:when>
  </xsl:choose>
  <xsl:choose>
    <xsl:when test="tei:altIdent=@ident">
      <xsl:value-of select="@ident"/>
    </xsl:when>
    <xsl:when test="tei:altIdent">
      <xsl:value-of select="normalize-space(tei:altIdent)"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:value-of select="@ident"/>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:choose>
    <xsl:when test="(number(tei:datatype/@maxOccurs) > 1 or tei:datatype/@maxOccurs='unbounded') and tei:datatype/rng:ref[@name='data.enumerated']">
      <xsl:text> NMTOKENS </xsl:text>
    </xsl:when>
    <xsl:when test="(number(tei:datatype/@maxOccurs) > 1 or  tei:datatype/@maxOccurs='unbounded') and tei:datatype/rng:ref[@name='data.name']">
      <xsl:text> NMTOKENS </xsl:text>
    </xsl:when>
    <xsl:when test="(number(tei:datatype/@maxOccurs) > 1 or  tei:datatype/@maxOccurs='unbounded') and tei:datatype/rng:data[@type='Name']">
      <xsl:text> NMTOKENS </xsl:text>
    </xsl:when>
    <xsl:when test="tei:valList[@type='closed']">
      <xsl:text> (</xsl:text>
      <xsl:for-each select="tei:valList/tei:valItem">
        <xsl:value-of select="@ident"/>
        <xsl:if test="following-sibling::tei:valItem">
          <xsl:text>|</xsl:text>
        </xsl:if>
      </xsl:for-each>
      <xsl:text>)</xsl:text>
    </xsl:when>
    <xsl:when test="tei:datatype/rng:data[@type='Name']">
      <xsl:text> NMTOKEN </xsl:text>
    </xsl:when>
    <xsl:when test="tei:datatype/@minOccurs or tei:datatype/@maxOccurs">
      <xsl:text> CDATA </xsl:text>
    </xsl:when>
    <xsl:when test="tei:datatype/rng:*">
      <xsl:apply-templates select="tei:datatype"/>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text> CDATA </xsl:text>
    </xsl:otherwise>
  </xsl:choose>
  <xsl:choose>
    <xsl:when test="string-length(tei:defaultVal) >0">
      <xsl:text> "</xsl:text>
      <xsl:value-of select="tei:defaultVal"/>
      <xsl:text>" </xsl:text>
    </xsl:when>
    <xsl:when test="parent::tei:attList[@org='choice']">
      <xsl:text> #IMPLIED</xsl:text>
    </xsl:when>
    <xsl:when test="@usage='req'">
      <xsl:text> #REQUIRED</xsl:text>
    </xsl:when>
    <xsl:otherwise>
      <xsl:text> #IMPLIED</xsl:text>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template bitOut
Namespace No namespace
Used by
Parameters
QName Namespace
content No namespace
element No namespace
grammar No namespace
Import precedence 4
Source
 
<xsl:template name="bitOut">
  <xsl:param name="grammar"/>
  <xsl:param name="element"/>
  <xsl:param name="content"/>
  <xsl:copy-of select="$content"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template CR
Namespace No namespace
Import precedence 4
Source
 
<xsl:template name="CR">
  <xsl:text>
</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:memberOftangleAtts
Namespace No namespace
Match tei:memberOf
Mode tangleAtts
References
Keys
IDENTS;
LOCALIDENTS
Parameter
localsource
Import precedence 4
Source
 
<xsl:template match="tei:memberOf" mode="tangleAtts">
  <xsl:variable name="ident">
    <xsl:value-of select="ancestor::tei:elementSpec/@ident|ancestor::tei:classSpec/@ident"/>
  </xsl:variable>
  <xsl:variable name="K" select="@key"/>
  <xsl:choose>
    <xsl:when test="key('IDENTS',$K)">
      <xsl:for-each select="key('IDENTS',@key)[1]">
        <xsl:apply-templates mode="tagatts" select="."/>
      </xsl:for-each>
    </xsl:when>
    <xsl:otherwise>
      <xsl:for-each select="document($localsource)/tei:TEI">
        <xsl:apply-templates mode="tagatts" select="key('LOCALIDENTS',$K)"/>
      </xsl:for-each>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:attReftangle
Namespace No namespace
Match tei:attRef
Mode tangle
Supersedes
Template
tei:attReftangle
Import precedence 4
Source
 
<xsl:template match="tei:attRef" mode="tangle">
  <xsl:text>
 %</xsl:text>
  <xsl:value-of select="@name"/>
  <xsl:text>;</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template checkClass
Namespace No namespace
Used by
References
Parameters
QName Namespace
id No namespace
Import precedence 4
Source
 
<xsl:template name="checkClass">
  <xsl:param name="id"/>
  <!-- should a class be included?
	 * it must exist in the ODD spec
	 * it must have other classes which point to it
	 * whatever it points to must have members which are in the ODD
    -->
  <xsl:for-each select="key('CLASSMEMBERS',$id)">
    <xsl:choose>
      <xsl:when test="self::tei:elementSpec and key('ELEMENTS',@ident)">
        <xsl:text>true</xsl:text>
      </xsl:when>
      <xsl:when test="self::tei:macroSpec and key('MACROS',@ident)">
        <xsl:text>true</xsl:text>
      </xsl:when>
      <xsl:when test="self::tei:classSpec and key('CLASSES',@ident)">
        <xsl:call-template name="checkClass">
          <xsl:with-param name="id" select="@ident"/>
        </xsl:call-template>
      </xsl:when>
    </xsl:choose>
  </xsl:for-each>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template dtdComment
Namespace No namespace
Used by
Parameters
QName Namespace
text No namespace
Import precedence 4
Source
 
<xsl:template name="dtdComment">
  <xsl:param name="text"/>
  <xsl:text>
<!--
</xsl:text>
  <xsl:value-of select="$text"/>
  <xsl:text>
-->
</xsl:text>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template checkEnd
Namespace No namespace
Used by
Import precedence 4
Source
 
<xsl:template name="checkEnd">
  <xsl:if test="count(parent::tei:content[parent::tei:elementSpec]/rng:*)>1 and     not(following-sibling::rng:*)">
    <xsl:text>)</xsl:text>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template checkStart
Namespace No namespace
Used by
Import precedence 4
Source
 
<xsl:template name="checkStart">
  <xsl:if test="count(parent::tei:content[parent::tei:elementSpec]/rng:*)>1">
    <xsl:choose>
      <xsl:when test="preceding-sibling::rng:*">
        <xsl:text>,</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>(</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:if>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template copyright
Namespace No namespace
Used by
Templates
byModule;
schemaOut
Import precedence 4
Source
 
<xsl:template name="copyright">
  <xsl:for-each select="/tei:TEI/tei:teiHeader/tei:fileDesc/tei:publicationStmt/tei:availability">
    <xsl:if test="count(tei:licence)>1">
      <xsl:text>This material is dual-licensed.
</xsl:text>
    </xsl:if>
    <xsl:apply-templates/>
  </xsl:for-each>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template tei:licence
Namespace No namespace
Match tei:licence
Mode #default
Import precedence 4
Source
 
<xsl:template match="tei:licence">
  <xsl:if test="@target">
    <xsl:text>[</xsl:text>
    <xsl:value-of select="@target"/>
    <xsl:text>] </xsl:text>
  </xsl:if>
  <xsl:apply-templates/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Template typewriter
Namespace No namespace
Used by
Templates
tei:code;
tei:tag
Parameters
QName Namespace
text No namespace
Import precedence 4
Source
 
<xsl:template name="typewriter">
  <xsl:param name="text"/>
</xsl:template>
Stylesheet location odd2dtd.xsl
Parameter autoGlobal
Namespace No namespace
Used by
Supersedes
Parameter
autoGlobal
Source
 
<xsl:param name="autoGlobal">false</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter verbose
Namespace No namespace
Used by
Supersedes
Parameter
verbose
Source
 
<xsl:param name="verbose"/>
Stylesheet location odd2dtd.xsl
Parameter outputDir
Namespace No namespace
Used by
Supersedes
Parameter
outputDir
Source
 
<xsl:param name="outputDir"/>
Stylesheet location odd2dtd.xsl
Parameter appendixWords
Namespace No namespace
Source
 
<xsl:param name="appendixWords">
</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter filesuffix
Namespace No namespace
Source
 
<xsl:param name="filesuffix"/>
Stylesheet location odd2dtd.xsl
Parameter numberBackHeadings
Namespace No namespace
Used by
Template
numberBackDiv
Supersedes
Parameter
numberBackHeadings
Source
 
<xsl:param name="numberBackHeadings">
</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter numberFrontHeadings
Namespace No namespace
Supersedes
Source
 
<xsl:param name="numberFrontHeadings">
</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter numberHeadings
Namespace No namespace
Used by
Template
numberBodyDiv
Supersedes
Parameter
numberHeadings
Source
 
<xsl:param name="numberHeadings">
</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter numberHeadingsDepth
Namespace No namespace
Supersedes
Source
 
<xsl:param name="numberHeadingsDepth">
</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter oddmode
Namespace No namespace
Used by
Supersedes
Parameter
oddmode
Source
 
<xsl:param name="oddmode">dtd</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter prenumberedHeadings
Namespace No namespace
Supersedes
Source
 
<xsl:param name="prenumberedHeadings">false</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter splitLevel
Namespace No namespace
Used by
Template
linkTogether
Supersedes
Parameter
splitLevel
Source
 
<xsl:param name="splitLevel">-1</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter generateNamespacePrefix
Namespace No namespace
Source
 
<xsl:param name="generateNamespacePrefix">false</xsl:param>
Stylesheet location odd2dtd.xsl
Parameter namespacePrefix
Namespace No namespace
Used by
Variable
nsPrefix
Source
 
<xsl:param name="namespacePrefix"/>
Stylesheet location odd2dtd.xsl
Variable nsPrefix
Namespace No namespace
Used by
References
Source
 
<xsl:variable name="nsPrefix">
  <xsl:choose>
    <xsl:when test="generateNamespacePrefix='false'"/>
    <xsl:when test="not($namespacePrefix='')">
      <xsl:value-of select="$namespacePrefix"/>
    </xsl:when>
    <xsl:when test="key('LISTSCHEMASPECS',$whichSchemaSpec)/@ns">
      <xsl:variable name="n" select="key('LISTSCHEMASPECS',whichSchemaSpec)/@ns"/>
      <xsl:choose>
        <xsl:when test="$n='http://www.w3.org/2005/11/its'">its:</xsl:when>
        <xsl:when test="$n='http://www.tei-c.org/ns/1.0'">tei:</xsl:when>
      </xsl:choose>
    </xsl:when>
  </xsl:choose>
</xsl:variable>
Stylesheet location odd2dtd.xsl
Output (default)
Namespace No namespace
Output properties
method encoding
text
Source
 
<xsl:output method="text"/>
Stylesheet location odd2dtd.xsl
Key Modules
Namespace No namespace
Match tei:moduleSpec
Use 1
Used by
Supersedes
Key
Modules
Source
 
<xsl:key match="tei:moduleSpec" name="Modules" use="1"/>
Stylesheet location odd2dtd.xsl
Key NSELEMENTS
Namespace No namespace
Match tei:elementSpec[@ns]|tei:attDef[@ns]
Use 1
Used by
Source
 
<xsl:key name="NSELEMENTS" match="tei:elementSpec[@ns]|tei:attDef[@ns]" use="1"/>
Stylesheet location odd2dtd.xsl
Key FILES
Namespace No namespace
Match tei:moduleSpec[@ident]
Use @ident
Used by
Source
 
<xsl:key match="tei:moduleSpec[@ident]" name="FILES" use="@ident"/>
Stylesheet location odd2dtd.xsl
Stylesheet documentation generated by ® XML Editor.