version="1.0">

<xsl:key name="targetdoc-key" match="document" use="@targetdoc" />

         use="concat(ancestor::document/@targetdoc, '/',

                     @targetptr, '/', ancestor::document/@lang)" />

<xsl:template name="select.target.database">

  <xsl:param name="targetdoc.att" select="''"/>

  <xsl:param name="targetptr.att" select="''"/>

  <xsl:param name="olink.lang" select="''"/>

  <xsl:variable name="xml.base" select="/*/@xml:base"/>

  <xsl:variable name="target.database.filename">

    <xsl:choose>

                   not(starts-with($target.database.document, 'file:/')) and

                   not(starts-with($target.database.document, '/'))">

        <xsl:call-template name="systemIdToBaseURI">

          <xsl:with-param name="systemId" select="$xml.base"/>

        </xsl:call-template>

        <xsl:value-of select="$target.database.document"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:value-of select="$target.database.document"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

      select="document($target.database.filename,/)"/>

  <xsl:choose>

    <xsl:when test="$target.database.document = ''">

      <xsl:message>

        <xsl:text>Olinks not processed: must specify a </xsl:text>

        <xsl:text>$target.database.document parameter
</xsl:text>

        <xsl:text>when using olinks with targetdoc </xsl:text>

        <xsl:text>and targetptr attributes.</xsl:text>

      </xsl:message>

    </xsl:when>

    <xsl:when test="not($target.database/*)">

      <xsl:message>

        <xsl:text>Olink error: could not open target database '</xsl:text>

        <xsl:value-of select="$target.database.filename"/>

        <xsl:text>'.</xsl:text>

      </xsl:message>

    </xsl:when>

    <xsl:otherwise>

      <xsl:value-of select="$target.database.filename"/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="select.olink.key">

  <xsl:param name="targetdoc.att" select="''"/>

  <xsl:param name="targetptr.att" select="''"/>

  <xsl:param name="olink.lang" select="''"/>

  <xsl:param name="target.database"/>

  <xsl:if test="$target.database/*">

    <xsl:variable name="olink.fallback.sequence">

      <xsl:call-template name="select.olink.lang.fallback">

        <xsl:with-param name="olink.lang" select="$olink.lang"/>

      </xsl:call-template>

    </xsl:variable>

    <xsl:call-template name="select.olink.key.in.lang">

      <xsl:with-param name="targetdoc.att" select="$targetdoc.att"/>

      <xsl:with-param name="targetptr.att" select="$targetptr.att"/>

      <xsl:with-param name="olink.lang" select="$olink.lang"/>

      <xsl:with-param name="target.database" select="$target.database"/>

      <xsl:with-param name="fallback.index" select="1"/>

                      select="$olink.fallback.sequence"/>

    </xsl:call-template>

  </xsl:if>

</xsl:template>

<xsl:template name="select.olink.key.in.lang">

  <xsl:param name="targetdoc.att" select="''"/>

  <xsl:param name="targetptr.att" select="''"/>

  <xsl:param name="olink.lang" select="''"/>

  <xsl:param name="target.database"/>

  <xsl:param name="fallback.index" select="1"/>

  <xsl:param name="olink.fallback.sequence" select="''"/>

  <xsl:variable name="target.lang">

    <xsl:call-template name="select.target.lang">

      <xsl:with-param name="fallback.index" select="$fallback.index"/>

                      select="$olink.fallback.sequence"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:if test="$olink.debug != 0">

    <xsl:message><xsl:text>Olink debug: cases for targetdoc='</xsl:text>

      <xsl:value-of select="$targetdoc.att"/>

      <xsl:text>' and targetptr='</xsl:text>

      <xsl:value-of select="$targetptr.att"/>

      <xsl:text>' in language '</xsl:text>

      <xsl:value-of select="$target.lang"/>

      <xsl:text>'.</xsl:text>

    </xsl:message>

  </xsl:if>

  <xsl:variable name="CaseA">

         targetptr.att = not blank

    -->

                  $targetptr.att != ''">

      <xsl:for-each select="$target.database">

                      select="concat($targetdoc.att, '/', 

                                     $targetptr.att, '/',

                                     $target.lang)"/>

        <xsl:choose>

          <xsl:when test="key('targetptr-key', $key)/@href != ''">

            <xsl:value-of select="$key"/>

            <xsl:if test="$olink.debug != 0">

              <xsl:message>Olink debug: CaseA matched.</xsl:message>

            </xsl:if>

          </xsl:when>

          <xsl:when test="$olink.debug != 0">

            <xsl:message>Olink debug: CaseA NOT matched</xsl:message>

          </xsl:when>

        </xsl:choose>

      </xsl:for-each>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="CaseB">

         targetptr.att = not blank

         prefer.internal.olink = not zero

         current.docid = not blank 

    -->

                  $targetptr.att != '' and

                  $current.docid != '' and

                  $prefer.internal.olink != 0">

      <xsl:for-each select="$target.database">

                      select="concat($current.docid, '/', 

                                     $targetptr.att, '/',

                                     $target.lang)"/>

        <xsl:choose>

          <xsl:when test="key('targetptr-key', $key)/@href != ''">

            <xsl:value-of select="$key"/>

            <xsl:if test="$olink.debug != 0">

              <xsl:message>Olink debug: CaseB matched.</xsl:message>

            </xsl:if>

          </xsl:when>

          <xsl:when test="$olink.debug != 0">

            <xsl:message>Olink debug: CaseB NOT matched</xsl:message>

          </xsl:when>

        </xsl:choose>

      </xsl:for-each>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="CaseC">

         targetptr.att = not blank

         current.docid = not blank 

    -->

                  $targetptr.att != '' and

                  $current.docid != ''">

      <xsl:for-each select="$target.database">

                      select="concat($current.docid, '/', 

                                     $targetptr.att, '/',

                                     $target.lang)"/>

        <xsl:choose>

          <xsl:when test="key('targetptr-key', $key)/@href != ''">

            <xsl:value-of select="$key"/>

            <xsl:if test="$olink.debug != 0">

              <xsl:message>Olink debug: CaseC matched.</xsl:message>

            </xsl:if>

          </xsl:when>

          <xsl:when test="$olink.debug != 0">

            <xsl:message>Olink debug: CaseC NOT matched.</xsl:message>

          </xsl:when>

        </xsl:choose>

      </xsl:for-each>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="CaseD">

         targetptr.att = not blank

         current.docid = blank 

    -->

                  $targetptr.att != '' and

                  string-length($current.docid) = 0 and

                  count($target.database//document) = 1">

      <xsl:for-each select="$target.database">

                      select="concat(.//document/@targetdoc, '/', 

                                     $targetptr.att, '/',

                                     $target.lang)"/>

        <xsl:choose>

          <xsl:when test="key('targetptr-key', $key)/@href != ''">

            <xsl:value-of select="$key"/>

            <xsl:if test="$olink.debug != 0">

              <xsl:message>Olink debug: CaseD matched.</xsl:message>

            </xsl:if>

          </xsl:when>

          <xsl:when test="$olink.debug != 0">

            <xsl:message>Olink debug: CaseD NOT matched</xsl:message>

          </xsl:when>

        </xsl:choose>

      </xsl:for-each>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="CaseE">

         targetptr.att = blank

    -->

                  string-length($targetptr.att) = 0">

      <xsl:variable name="rootid">

        <xsl:choose>

          <xsl:when test="$target.lang != ''">

            <xsl:value-of select="$target.database//document[@targetdoc = $targetdoc.att and @lang = $target.lang]/*[1]/@targetptr"/>

          </xsl:when>

          <xsl:otherwise>

            <xsl:value-of select="$target.database//document[@targetdoc = $targetdoc.att and not(@lang)]/*[1]/@targetptr"/>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:variable>

      <xsl:for-each select="$target.database">

                      select="concat($targetdoc.att, '/', 

                                     $rootid, '/',

                                     $target.lang)"/>

        <xsl:choose>

          <xsl:when test="key('targetptr-key', $key)/@href != ''">

            <xsl:value-of select="$key"/>

            <xsl:if test="$olink.debug != 0">

              <xsl:message>Olink debug: CaseE matched.</xsl:message>

            </xsl:if>

          </xsl:when>

          <xsl:when test="$olink.debug != 0">

            <xsl:message>Olink debug: CaseE NOT matched.</xsl:message>

          </xsl:when>

        </xsl:choose>

      </xsl:for-each>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="CaseF">

         targetptr.att = blank

         prefer.internal.olink = not zero

         current.docid = not blank 

    -->

                  string-length($targetptr.att) = 0 and

                  $current.docid != '' and

                  $prefer.internal.olink != 0">

      <xsl:variable name="rootid">

        <xsl:choose>

          <xsl:when test="$target.lang != ''">

            <xsl:value-of select="$target.database//document[@targetdoc = $current.docid and @lang = $target.lang]/*[1]/@targetptr"/>

          </xsl:when>

          <xsl:otherwise>

            <xsl:value-of select="$target.database//document[@targetdoc = $current.docid and not(@lang)]/*[1]/@targetptr"/>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:variable>

      <xsl:for-each select="$target.database">

                      select="concat($current.docid, '/', 

                                     $rootid, '/',

                                     $target.lang)"/>

        <xsl:choose>

          <xsl:when test="key('targetptr-key', $key)/@href != ''">

            <xsl:value-of select="$key"/>

            <xsl:if test="$olink.debug != 0">

              <xsl:message>Olink debug: CaseF matched.</xsl:message>

            </xsl:if>

          </xsl:when>

          <xsl:when test="$olink.debug != 0">

            <xsl:message>Olink debug: CaseF NOT matched.</xsl:message>

          </xsl:when>

        </xsl:choose>

      </xsl:for-each>

    </xsl:if>

  </xsl:variable>

  <xsl:variable name="selected.key">

    <xsl:choose>

      <xsl:when test="$CaseB != ''">

        <xsl:value-of select="$CaseB"/>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: CaseB key is the final selection: </xsl:text>

            <xsl:value-of select="$CaseB"/>

          </xsl:message>

        </xsl:if>

      </xsl:when>

      <xsl:when test="$CaseA != ''">

        <xsl:value-of select="$CaseA"/>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: CaseA key is the final selection: </xsl:text>

            <xsl:value-of select="$CaseA"/>

          </xsl:message>

        </xsl:if>

      </xsl:when>

      <xsl:when test="$CaseC != ''">

        <xsl:value-of select="$CaseC"/>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: CaseC key is the final selection: </xsl:text>

            <xsl:value-of select="$CaseC"/>

          </xsl:message>

        </xsl:if>

      </xsl:when>

      <xsl:when test="$CaseD != ''">

        <xsl:value-of select="$CaseD"/>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: CaseD key is the final selection: </xsl:text>

            <xsl:value-of select="$CaseD"/>

          </xsl:message>

        </xsl:if>

      </xsl:when>

      <xsl:when test="$CaseF != ''">

        <xsl:value-of select="$CaseF"/>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: CaseF key is the final selection: </xsl:text>

            <xsl:value-of select="$CaseF"/>

          </xsl:message>

        </xsl:if>

      </xsl:when>

      <xsl:when test="$CaseE != ''">

        <xsl:value-of select="$CaseE"/>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: CaseE key is the final selection: </xsl:text>

            <xsl:value-of select="$CaseE"/>

          </xsl:message>

        </xsl:if>

      </xsl:when>

      <xsl:otherwise>

        <xsl:if test="$olink.debug != 0">

          <xsl:message>

            <xsl:text>Olink debug: No case matched for lang '</xsl:text>

            <xsl:value-of select="$target.lang"/>

            <xsl:text>'.</xsl:text>

          </xsl:message>

        </xsl:if>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$selected.key != ''">

      <xsl:value-of select="$selected.key"/>

    </xsl:when>

                    string-length($target.lang) = 0">

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="select.olink.key.in.lang">

        <xsl:with-param name="targetdoc.att" select="$targetdoc.att"/>

        <xsl:with-param name="targetptr.att" select="$targetptr.att"/>

        <xsl:with-param name="olink.lang" select="$olink.lang"/>

        <xsl:with-param name="target.database" select="$target.database"/>

        <xsl:with-param name="fallback.index" select="$fallback.index + 1"/>

                        select="$olink.fallback.sequence"/>

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="select.target.lang">

  <xsl:param name="fallback.index" select="1"/>

  <xsl:param name="olink.fallback.sequence" select="''"/>

                select="substring-before($olink.fallback.sequence, ' ')"/>

                select="substring-after($olink.fallback.sequence, ' ')"/>

  <xsl:choose>

    <xsl:when test="$fallback.index = 1">

      <xsl:value-of select="$firstlang"/>

    </xsl:when>

    <xsl:when test="$fallback.index > 1">

      <xsl:call-template name="select.target.lang">

        <xsl:with-param name="fallback.index" select="$fallback.index - 1"/>

                        select="$rest"/>

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="select.olink.lang.fallback">

  <xsl:param name="olink.lang" select="''"/>

                        $olink.lang.fallback.sequence)), ' ')"/>

</xsl:template>

<xsl:template name="make.olink.href">

  <xsl:param name="olink.key" select="''"/>

  <xsl:param name="target.database"/>

  <xsl:if test="$olink.key != ''">

    <xsl:variable name="target.href" >

      <xsl:for-each select="$target.database" >

        <xsl:value-of select="key('targetptr-key', $olink.key)/@href" />

      </xsl:for-each>

    </xsl:variable>

    <xsl:variable name="targetdoc">

      <xsl:value-of select="substring-before($olink.key, '/')"/>

    </xsl:variable>

    <xsl:variable name="use.sitemap">

      <xsl:choose>

        <xsl:when test="$target.database//sitemap">1</xsl:when>

        <xsl:otherwise>0</xsl:otherwise>

      </xsl:choose>

    </xsl:variable>

    <xsl:variable name="baseuri" >

      <xsl:choose>

        <xsl:when test="$use.sitemap != 0" >

          <xsl:choose>

            <xsl:when test="$current.docid != ''">

              <xsl:variable name="currentdoc.key" >

                <xsl:for-each select="$target.database" >

                                        $current.docid)/@targetdoc" />

                </xsl:for-each>

              </xsl:variable>

              <xsl:choose>

                <xsl:when test="$currentdoc.key != ''">

                  <xsl:for-each select="$target.database" >

                    <xsl:call-template name="targetpath" >

                          select="key('targetdoc-key', $current.docid)/parent::dir"/>

                      <xsl:with-param name="targetdoc" select="$targetdoc"/>

                    </xsl:call-template>

                  </xsl:for-each >

                </xsl:when>

                <xsl:otherwise>

                  <xsl:message>

                    <xsl:text>Olink error: cannot compute relative </xsl:text>

                    <xsl:text>sitemap path because $current.docid '</xsl:text>

                    <xsl:value-of select="$current.docid"/>

                    <xsl:text>' not found in target database.</xsl:text>

                  </xsl:message>

                </xsl:otherwise>

              </xsl:choose>

            </xsl:when>

            <xsl:otherwise>

              <xsl:message>

                <xsl:text>Olink warning: cannot compute relative </xsl:text>

                <xsl:text>sitemap path without $current.docid parameter</xsl:text>

              </xsl:message>

            </xsl:otherwise>

          </xsl:choose> 

          <xsl:variable name="docbaseuri">

            <xsl:for-each select="$target.database" >

              <xsl:value-of select="key('targetdoc-key', $targetdoc)/@baseuri" />

            </xsl:for-each>

          </xsl:variable>

          <xsl:if test="$docbaseuri != ''" >

            <xsl:value-of select="$docbaseuri"/>

          </xsl:if>

        </xsl:when>

        <xsl:otherwise>

          <xsl:variable name="docbaseuri">

            <xsl:for-each select="$target.database" >

              <xsl:value-of select="key('targetdoc-key', $targetdoc)/@baseuri" />

            </xsl:for-each>

          </xsl:variable>

          <xsl:if test="$docbaseuri != ''" >

            <xsl:value-of select="$docbaseuri"/>

          </xsl:if>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:variable>

    <xsl:if test="$baseuri != ''">

      <xsl:value-of select="$baseuri"/>

      <xsl:if test="substring($target.href,1,1) != '#'">

      </xsl:if>

    </xsl:if>

          translate(substring($baseuri, string-length($baseuri) - 3),

                    'PDF', 'pdf') = '.pdf'

          and starts-with($target.href, '#') )">

      <xsl:value-of select="$target.href"/>

    </xsl:if>

  </xsl:if>

</xsl:template>

<xsl:template name="olink.from.uri">

  <xsl:param name="target.database"/>

  <xsl:param name="object" select="NotAnElement"/>

  <xsl:param name="object.targetdoc" select="$current.docid"/>

           select="concat($object/ancestor::*[last()]/@lang,

                          $object/ancestor::*[last()]/@xml:lang)"/>

  <xsl:variable name="parent.id">

    <xsl:call-template name="object.id">

      <xsl:with-param name="object" select="$object"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="from.key">

    <xsl:call-template name="select.olink.key">

      <xsl:with-param name="targetdoc.att" select="$object.targetdoc"/>

      <xsl:with-param name="targetptr.att" select="$parent.id"/>

      <xsl:with-param name="olink.lang" select="$object.lang"/>

      <xsl:with-param name="target.database" select="$target.database"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="from.olink.href">

    <xsl:for-each select="$target.database" >

      <xsl:value-of select="key('targetptr-key', $from.key)/@href" />

    </xsl:for-each>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$from.olink.href != ''">

      <xsl:value-of select="$from.olink.href"/>

    </xsl:when>

    <xsl:when test="not($object/parent::*)">

      <xsl:value-of select="$from.olink.href"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="olink.from.uri">

        <xsl:with-param name="target.database" select="$target.database"/>

        <xsl:with-param name="object" select="$object/parent::*"/>

        <xsl:with-param name="object.targetdoc" select="$object.targetdoc"/>

        <xsl:with-param name="object.lang" select="$object.lang"/>

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="olink.hottext">

  <xsl:param name="target.database"/>

  <xsl:param name="olink.lang" select="''"/>

  <xsl:param name="olink.key" select="''"/>

  <xsl:param name="referrer" select="."/>

  <xsl:param name="xrefstyle">

    <xsl:choose>

                      and $use.role.as.xrefstyle != 0">

        <xsl:value-of select="@role"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:value-of select="@xrefstyle"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:param>

  <xsl:choose>

    <xsl:when test="child::text() or child::*">

      <xsl:apply-templates/>

    </xsl:when>

    <xsl:when test="$olink.key != ''">

      <xsl:variable name="xref.text" >

        <xsl:for-each select="$target.database" >

          <xsl:call-template name="insert.targetdb.data">

                  select="key('targetptr-key', $olink.key)/xreftext/node()" />

          </xsl:call-template>

        </xsl:for-each>

      </xsl:variable>

      <xsl:variable name="xref.number" >

        <xsl:for-each select="$target.database" >

          <xsl:value-of select="key('targetptr-key', $olink.key)/@number" />

        </xsl:for-each>

      </xsl:variable>

      <xsl:variable name="target.elem" >

        <xsl:for-each select="$target.database" >

          <xsl:value-of select="key('targetptr-key', $olink.key)/@element" />

        </xsl:for-each>

      </xsl:variable>

      <xsl:variable name="lang">

        <xsl:variable name="candidate">

          <xsl:for-each select="$target.database" >

                      select="key('targetptr-key', $olink.key)/@lang" />

          </xsl:for-each>

        </xsl:variable>

        <xsl:choose>

          <xsl:when test="$candidate != ''">

            <xsl:value-of select="$candidate"/>

          </xsl:when>

          <xsl:otherwise>

            <xsl:value-of select="$olink.lang"/>

          </xsl:otherwise>

        </xsl:choose>

      </xsl:variable>

      <xsl:variable name="targetdoc">

        <xsl:value-of select="substring-before($olink.key, '/')"/>

      </xsl:variable>

      <xsl:choose>

                        starts-with(normalize-space($xrefstyle), 'select:') and

                        (contains($xrefstyle, 'nodocname') or

                        contains($xrefstyle, 'nopage')) and

                        not(contains($xrefstyle, 'title')) and

                        not(contains($xrefstyle, 'label'))"> 

          <xsl:copy-of select="$xref.text"/>

        </xsl:when>

        <xsl:when test="$xrefstyle != ''">

          <xsl:if test="$olink.debug != 0">

            <xsl:message>

              <xsl:text>xrefstyle is '</xsl:text>

              <xsl:value-of select="$xrefstyle"/>

              <xsl:text>'.</xsl:text>

            </xsl:message>

          </xsl:if>

          <xsl:variable name="template">

            <xsl:choose>

                                          'select:')">

                <xsl:call-template name="make.gentext.template">

                  <xsl:with-param name="xrefstyle" select="$xrefstyle"/>

                  <xsl:with-param name="purpose" select="'olink'"/>

                  <xsl:with-param name="referrer" select="."/>

                  <xsl:with-param name="target.elem" select="$target.elem"/>

                </xsl:call-template>

              </xsl:when>

                                          'template:')">

                                 normalize-space($xrefstyle), 'template:')"/>

              </xsl:when>

              <xsl:otherwise>

                     falls back to no style -->

                <xsl:variable name="xref-context">

                  <xsl:call-template name="gentext.template">

                    <xsl:with-param name="context" select="'xref'"/>

                    <xsl:with-param name="name" select="$target.elem"/>

                    <xsl:with-param name="lang" select="$lang"/>

                  </xsl:call-template>

                </xsl:variable>

                <xsl:variable name="styled-xref-context">

                  <xsl:call-template name="gentext.template">

                    <xsl:with-param name="context" select="'xref'"/>

                    <xsl:with-param name="name" select="$target.elem"/>

                    <xsl:with-param name="lang" select="$lang"/>

                    <xsl:with-param name="xrefstyle" select="$xrefstyle"/>

                  </xsl:call-template>

                </xsl:variable>

                <xsl:variable name="xref-number-context">

                  <xsl:call-template name="gentext.template">

                    <xsl:with-param name="context" select="'xref-number'"/>

                    <xsl:with-param name="name" select="$target.elem"/>

                    <xsl:with-param name="lang" select="$lang"/>

                  </xsl:call-template>

                </xsl:variable>

                <xsl:variable name="styled-xref-number-context">

                  <xsl:call-template name="gentext.template">

                    <xsl:with-param name="context" select="'xref-number'"/>

                    <xsl:with-param name="name" select="$target.elem"/>

                    <xsl:with-param name="lang" select="$lang"/>

                    <xsl:with-param name="xrefstyle" select="$xrefstyle"/>

                  </xsl:call-template>

                </xsl:variable>

                <xsl:variable name="xref-number-and-title-context">

                  <xsl:call-template name="gentext.template">

                                    select="'xref-number-and-title'"/>

                    <xsl:with-param name="name" select="$target.elem"/>

                    <xsl:with-param name="lang" select="$lang"/>

                  </xsl:call-template>

                </xsl:variable>

                <xsl:variable name="styled-xref-number-and-title-context">

                  <xsl:call-template name="gentext.template">

                                    select="'xref-number-and-title'"/>

                    <xsl:with-param name="name" select="$target.elem"/>

                    <xsl:with-param name="lang" select="$lang"/>

                    <xsl:with-param name="xrefstyle" select="$xrefstyle"/>

                  </xsl:call-template>

                </xsl:variable>

                <xsl:choose>

                                 $styled-xref-number-and-title-context and

                                 $xref.number != '' and

                                 $xref.with.number.and.title != 0">

                            select="$styled-xref-number-and-title-context"/>

                  </xsl:when>

                                 $styled-xref-number-context and

                                 $xref.number != ''">

                    <xsl:value-of select="$styled-xref-number-context"/>

                  </xsl:when>

                  <xsl:when test="$xref-context != $styled-xref-context">

                    <xsl:value-of select="$styled-xref-context"/>

                  </xsl:when>

                                 $xref.number != '' and

                                 $xref.with.number.and.title != 0">

                            select="$xref-number-and-title-context"/>

                    <xsl:if test="$olink.debug">

                      <xsl:message>

                        <xsl:text>Olink error: no gentext template</xsl:text>

                        <xsl:text> exists for xrefstyle '</xsl:text>

                        <xsl:value-of select="$xrefstyle"/>

                        <xsl:text>' for element '</xsl:text>

                        <xsl:value-of select="$target.elem"/>

                        <xsl:text>' in language '</xsl:text>

                        <xsl:value-of select="$lang"/>

                        <xsl:text>' in context 'xref-number-and-title</xsl:text>

                        <xsl:text>'. Using template without @style.</xsl:text>

                      </xsl:message>

                    </xsl:if>

                  </xsl:when>

                                 $xref.number != ''">

                    <xsl:value-of select="$xref-number-context"/>

                    <xsl:if test="$olink.debug">

                      <xsl:message>

                        <xsl:text>Olink error: no gentext template</xsl:text>

                        <xsl:text> exists for xrefstyle '</xsl:text>

                        <xsl:value-of select="$xrefstyle"/>

                        <xsl:text>' for element '</xsl:text>

                        <xsl:value-of select="$target.elem"/>

                        <xsl:text>' in language '</xsl:text>

                        <xsl:value-of select="$lang"/>

                        <xsl:text>' in context 'xref-number</xsl:text>

                        <xsl:text>'. Using template without @style.</xsl:text>

                      </xsl:message>

                    </xsl:if>

                  </xsl:when>

                  <xsl:when test="$xref-context != ''">

                    <xsl:value-of select="$xref-context"/>

                    <xsl:if test="$olink.debug">

                      <xsl:message>

                        <xsl:text>Olink error: no gentext template</xsl:text>

                        <xsl:text> exists for xrefstyle '</xsl:text>

                        <xsl:value-of select="$xrefstyle"/>

                        <xsl:text>' for element '</xsl:text>

                        <xsl:value-of select="$target.elem"/>

                        <xsl:text>' in language '</xsl:text>

                        <xsl:value-of select="$lang"/>

                        <xsl:text>' in context 'xref</xsl:text>

                        <xsl:text>'. Using template without @style.</xsl:text>

                      </xsl:message>

                    </xsl:if>

                  </xsl:when>

                  <xsl:otherwise>

                    <xsl:message>

                      <xsl:text>Olink error: no gentext template</xsl:text>

                      <xsl:text> exists for xrefstyle '</xsl:text>

                      <xsl:value-of select="$xrefstyle"/>

                      <xsl:text>' for element '</xsl:text>

                      <xsl:value-of select="$target.elem"/>

                      <xsl:text>' in language '</xsl:text>

                      <xsl:value-of select="$lang"/>

                      <xsl:text>'. Trying '%t'.</xsl:text>

                    </xsl:message>

                    <xsl:value-of select="'%t'"/>

                  </xsl:otherwise>

                </xsl:choose>

              </xsl:otherwise>

            </xsl:choose>

          </xsl:variable>

          <xsl:if test="$olink.debug != 0">

            <xsl:message>

              <xsl:text>Olink debug: xrefstyle template is '</xsl:text>

              <xsl:value-of select="$template"/>

              <xsl:text>'.</xsl:text>

            </xsl:message>

          </xsl:if>

          <xsl:call-template name="substitute-markup">

            <xsl:with-param name="template" select="$template"/>

            <xsl:with-param name="title">

              <xsl:for-each select="$target.database" >

                <xsl:call-template name="insert.targetdb.data">

                                  select="key('targetptr-key', $olink.key)/ttl" />

                </xsl:call-template>

              </xsl:for-each>

            </xsl:with-param>

            <xsl:with-param name="label">

              <xsl:for-each select="$target.database" >

                        select="key('targetptr-key', $olink.key)/@number" />

              </xsl:for-each>

            </xsl:with-param>

            <xsl:with-param name="pagenumber">

              <xsl:for-each select="$target.database" >

                        select="key('targetptr-key', $olink.key)/@page" />

              </xsl:for-each>

            </xsl:with-param>

            <xsl:with-param name="docname">

              <xsl:for-each select="$target.database" >

                <xsl:call-template name="insert.targetdb.data">

                       select="key('targetdoc-key', $targetdoc)/div[1]/ttl" />