xmlns:db="http://docbook.org/ns/docbook"

                xmlns:doc="http://nwalsh.com/xsl/documentation/1.0"

                xmlns:dyn="http://exslt.org/dynamic"

                xmlns:saxon="http://icl.com/saxon"

                exclude-result-prefixes="db doc dyn saxon"

                version='1.0'>

     Id

     ********************************************************************

     This file is part of the XSL DocBook Stylesheet distribution.

     See ../README or http://docbook.sf.net/release/xsl/current/ for

     copyright and other information.

     ******************************************************************** -->

<doc:reference xmlns="" xml:id="base">

  <info>

    <title>Common » Base Template Reference</title>

    <releaseinfo role="meta">

      $Id

    </releaseinfo>

  </info>

  <partintro xml:id="partintro">

    <title>Introduction</title>

    <para>This is technical reference documentation for the “base”

      set of common templates in the DocBook XSL Stylesheets.</para>

    <para>This is not intended to be user documentation. It is

      provided for developers writing customization layers for the

      stylesheets.</para>

  </partintro>

</doc:reference>

<xsl:preserve-space elements="*"/>

abstract affiliation anchor answer appendix area areaset areaspec artheader

article articleinfo audiodata audioobject author authorblurb authorgroup

beginpage bibliodiv biblioentry bibliography biblioset blockquote book

bookbiblio bookinfo callout calloutlist caption caution chapter

citerefentry cmdsynopsis co collab colophon colspec confgroup

copyright dedication docinfo editor entrytbl epigraph equation

example figure footnote footnoteref formalpara funcprototype

funcsynopsis glossary glossdef glossdiv glossentry glosslist graphicco

group highlights imagedata imageobject imageobjectco important index

indexdiv indexentry indexterm info informalequation informalexample

informalfigure informaltable inlineequation inlinemediaobject

itemizedlist itermset keycombo keywordset legalnotice listitem lot

mediaobject mediaobjectco menuchoice msg msgentry msgexplan msginfo

msgmain msgrel msgset msgsub msgtext note objectinfo

orderedlist othercredit part partintro preface printhistory procedure

programlistingco publisher qandadiv qandaentry qandaset question

refentry reference refmeta refnamediv refsection refsect1 refsect1info refsect2

refsect2info refsect3 refsect3info refsynopsisdiv refsynopsisdivinfo

revhistory revision row sbr screenco screenshot sect1 sect1info sect2

sect2info sect3 sect3info sect4 sect4info sect5 sect5info section

sectioninfo seglistitem segmentedlist seriesinfo set setindex setinfo

shortcut sidebar simplelist simplesect spanspec step subject

subjectset substeps synopfragment table tbody textobject tfoot tgroup

thead tip toc tocchap toclevel1 toclevel2 toclevel3 toclevel4

toclevel5 tocpart varargs variablelist varlistentry videodata

videoobject void warning subjectset

classsynopsis

constructorsynopsis

destructorsynopsis

fieldsynopsis

methodparam

methodsynopsis

ooclass

ooexception

oointerface

simplemsgentry

manvolnum

"/>

     stripping setup is not applied on the RTF built in stripNS mode, when

     xsl:imports are used in stylesheets, which is the case in dblatex

     -->

db:abstract db:affiliation db:anchor db:answer db:appendix db:area db:areaset

db:areaspec db:artheader db:article db:audiodata db:audioobject db:author

db:authorblurb db:authorgroup db:beginpage db:bibliodiv db:biblioentry

db:bibliography db:biblioset db:blockquote db:book db:bookbiblio

db:callout db:calloutlist db:caption db:caution db:chapter db:citerefentry

db:cmdsynopsis db:co db:collab db:colophon db:colspec db:confgroup db:copyright

db:dedication db:docinfo db:editor db:entrytbl db:epigraph db:equation

db:example db:figure db:footnote db:footnoteref db:formalpara db:funcprototype

db:funcsynopsis db:glossary db:glossdef db:glossdiv db:glossentry db:glosslist

db:graphicco db:group db:highlights db:imagedata db:imageobject

db:imageobjectco db:important db:index db:indexdiv db:indexentry db:indexterm

db:info db:informalequation db:informalexample db:informalfigure

db:informaltable db:inlineequation db:inlinemediaobject db:itemizedlist

db:itermset db:keycombo db:keywordset db:legalnotice db:listitem db:lot

db:mediaobject db:mediaobjectco db:menuchoice db:msg db:msgentry db:msgexplan

db:msginfo db:msgmain db:msgrel db:msgset db:msgsub db:msgtext db:note

db:orderedlist db:othercredit db:part db:partintro db:preface

db:printhistory db:procedure db:programlistingco db:publisher db:qandadiv

db:qandaentry db:qandaset db:question db:refentry db:reference db:refmeta

db:refnamediv db:refsection db:refsect1 db:refsect2 db:refsect3

db:refsynopsisdiv db:revhistory db:revision db:row db:sbr db:screenco

db:screenshot db:sect1 db:sect2 db:sect3 db:sect4 db:sect5 db:section

db:seglistitem db:segmentedlist db:seriesinfo db:set

db:setindex db:setinfo db:shortcut db:sidebar db:simplelist db:simplesect

db:spanspec db:step db:subject db:subjectset db:substeps db:synopfragment

db:table db:tbody db:textobject db:tfoot db:tgroup db:thead db:tip db:toc

db:tocchap db:toclevel1 db:toclevel2 db:toclevel3 db:toclevel4 db:toclevel5

db:tocpart db:varargs db:variablelist db:varlistentry db:videodata

db:videoobject db:void db:warning db:subjectset

db:classsynopsis

db:constructorsynopsis

db:destructorsynopsis

db:fieldsynopsis

db:methodparam

db:methodsynopsis

db:ooclass

db:ooexception

db:oointerface

db:simplemsgentry

db:manvolnum

"/>

<doc:template name="is.component" xmlns="">

<refpurpose>Tests if a given node is a component-level element</refpurpose>

<refdescription id="is.component-desc">

<para>This template returns '1' if the specified node is a component

(Chapter, Appendix, etc.), and '0' otherwise.</para>

</refdescription>

<refparameter id="is.component-params">

<variablelist>

<varlistentry><term>node</term>

<listitem>

<para>The node which is to be tested.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="is.component-returns">

<para>This template returns '1' if the specified node is a component

(Chapter, Appendix, etc.), and '0' otherwise.</para>

</refreturn>

</doc:template>

<xsl:template name="is.component">

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

  <xsl:choose>

                    or local-name($node) = 'article'

                    or local-name($node) = 'chapter'

                    or local-name($node) = 'preface'

                    or local-name($node) = 'bibliography'

                    or local-name($node) = 'glossary'

                    or local-name($node) = 'index'">1</xsl:when>

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

  </xsl:choose>

</xsl:template>

<doc:template name="is.section" xmlns="">

<refpurpose>Tests if a given node is a section-level element</refpurpose>

<refdescription id="is.section-desc">

<para>This template returns '1' if the specified node is a section

(Section, Sect1, Sect2, etc.), and '0' otherwise.</para>

</refdescription>

<refparameter id="is.section-params">

<variablelist>

<varlistentry><term>node</term>

<listitem>

<para>The node which is to be tested.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="is.section-returns">

<para>This template returns '1' if the specified node is a section

(Section, Sect1, Sect2, etc.), and '0' otherwise.</para>

</refreturn>

</doc:template>

<xsl:template name="is.section">

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

  <xsl:choose>

                    or local-name($node) = 'sect1'

                    or local-name($node) = 'sect2'

                    or local-name($node) = 'sect3'

                    or local-name($node) = 'sect4'

                    or local-name($node) = 'sect5'

                    or local-name($node) = 'refsect1'

                    or local-name($node) = 'refsect2'

                    or local-name($node) = 'refsect3'

                    or local-name($node) = 'simplesect'">1</xsl:when>

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

  </xsl:choose>

</xsl:template>

<doc:template name="section.level" xmlns="">

<refpurpose>Returns the hierarchical level of a section</refpurpose>

<refdescription id="section.level-desc">

<para>This template calculates the hierarchical level of a section.

The element <tag>sect1</tag> is at level 1, <tag>sect2</tag> is

at level 2, etc.</para>

<para>Recursive sections are calculated down to the fifth level.</para>

</refdescription>

<refparameter id="section.level-params">

<variablelist>

<varlistentry><term>node</term>

<listitem>

<para>The section node for which the level should be calculated.

Defaults to the context node.</para>

</listitem>

</varlistentry>

</variablelist>

</refparameter>

<refreturn id="section.level-returns">

<para>The section level, <quote>1</quote>, <quote>2</quote>, etc.

</para>

</refreturn>

</doc:template>

<xsl:template name="section.level">

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

  <xsl:choose>

    <xsl:when test="local-name($node)='sect1'">1</xsl:when>

    <xsl:when test="local-name($node)='sect2'">2</xsl:when>

    <xsl:when test="local-name($node)='sect3'">3</xsl:when>

    <xsl:when test="local-name($node)='sect4'">4</xsl:when>

    <xsl:when test="local-name($node)='sect5'">5</xsl:when>

    <xsl:when test="local-name($node)='section'">

      <xsl:choose>

        <xsl:when test="$node/../../../../../../section">6</xsl:when>

        <xsl:when test="$node/../../../../../section">5</xsl:when>

        <xsl:when test="$node/../../../../section">4</xsl:when>

        <xsl:when test="$node/../../../section">3</xsl:when>

        <xsl:when test="$node/../../section">2</xsl:when>

        <xsl:otherwise>1</xsl:otherwise>

      </xsl:choose>

    </xsl:when>

                    local-name($node)='refsect2' or

                    local-name($node)='refsect3' or

                    local-name($node)='refsection' or

                    local-name($node)='refsynopsisdiv'">

      <xsl:call-template name="refentry.section.level">

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

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="local-name($node)='simplesect'">

      <xsl:choose>

        <xsl:when test="$node/../../sect1">2</xsl:when>

        <xsl:when test="$node/../../sect2">3</xsl:when>

        <xsl:when test="$node/../../sect3">4</xsl:when>

        <xsl:when test="$node/../../sect4">5</xsl:when>

        <xsl:when test="$node/../../sect5">5</xsl:when>

        <xsl:when test="$node/../../section">

          <xsl:choose>

            <xsl:when test="$node/../../../../../section">5</xsl:when>

            <xsl:when test="$node/../../../../section">4</xsl:when>

            <xsl:when test="$node/../../../section">3</xsl:when>

            <xsl:otherwise>2</xsl:otherwise>

          </xsl:choose>

        </xsl:when>

        <xsl:otherwise>1</xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:otherwise>1</xsl:otherwise>

  </xsl:choose>

</xsl:template>

<doc:template name="qanda.section.level" xmlns="">

<refpurpose>Returns the hierarchical level of a QandASet</refpurpose>

<refdescription id="qanda.section.level-desc">

<para>This template calculates the hierarchical level of a QandASet.

</para>

</refdescription>

<refreturn id="qanda.section.level-returns">

<para>The level, <quote>1</quote>, <quote>2</quote>, etc.

</para>

</refreturn>

</doc:template>

<xsl:template name="qanda.section.level">

                select="(ancestor::section

                         |ancestor::simplesect

                         |ancestor::sect5

                         |ancestor::sect4

                         |ancestor::sect3

                         |ancestor::sect2

                         |ancestor::sect1

                         |ancestor::refsect3

                         |ancestor::refsect2

                         |ancestor::refsect1)[last()]"/>

  <xsl:choose>

    <xsl:when test="count($section) = '0'">1</xsl:when>

    <xsl:otherwise>

      <xsl:variable name="slevel">

        <xsl:call-template name="section.level">

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

        </xsl:call-template>

      </xsl:variable>

      <xsl:value-of select="$slevel + 1"/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="refentry.section.level">

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

  <xsl:variable name="RElevel">

    <xsl:call-template name="refentry.level">

      <xsl:with-param name="node" select="$node/ancestor::refentry[1]"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="levelinRE">

    <xsl:choose>

      <xsl:when test="local-name($node)='refsynopsisdiv'">1</xsl:when>

      <xsl:when test="local-name($node)='refsect1'">1</xsl:when>

      <xsl:when test="local-name($node)='refsect2'">2</xsl:when>

      <xsl:when test="local-name($node)='refsect3'">3</xsl:when>

      <xsl:when test="local-name($node)='refsection'">

        <xsl:choose>

          <xsl:when test="$node/../../../../../refsection">5</xsl:when>

          <xsl:when test="$node/../../../../refsection">4</xsl:when>

          <xsl:when test="$node/../../../refsection">3</xsl:when>

          <xsl:when test="$node/../../refsection">2</xsl:when>

          <xsl:otherwise>1</xsl:otherwise>

        </xsl:choose>

      </xsl:when>

    </xsl:choose>

  </xsl:variable>

  <xsl:value-of select="$levelinRE + $RElevel"/>

</xsl:template>

<xsl:template name="refentry.level">

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

                select="($node/ancestor::section |

                        $node/ancestor::sect1 |

                        $node/ancestor::sect2 |

                        $node/ancestor::sect3 |

                        $node/ancestor::sect4 |

                        $node/ancestor::sect5)[last()]"/>

  <xsl:choose>

    <xsl:when test="$container">

      <xsl:variable name="slevel">

        <xsl:call-template name="section.level">

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

        </xsl:call-template>

      </xsl:variable>

      <xsl:value-of select="$slevel + 1"/>

    </xsl:when>

    <xsl:otherwise>1</xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="qandadiv.section.level">

  <xsl:variable name="section.level">

    <xsl:call-template name="qanda.section.level"/>

  </xsl:variable>

  <xsl:variable name="anc.divs" select="ancestor::qandadiv"/>

  <xsl:value-of select="count($anc.divs) + number($section.level)"/>

</xsl:template>

<xsl:template name="question.answer.label">

  <xsl:variable name="deflabel">

    <xsl:choose>

      <xsl:when test="ancestor-or-self::*[@defaultlabel]">

                              /@defaultlabel"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:value-of select="$qanda.defaultlabel"/>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:variable name="label" select="@label"/>

 (hnr      (hierarchical-number-recursive (normalize "qandadiv") node))

         (parsect  (ancestor-member node (section-element-list)))

         (defnum   (if (and %qanda-inherit-numeration% 

                            %section-autolabel%)

                       (if (node-list-empty? parsect)

                           (section-autolabel-prefix node)

                           (section-autolabel parsect))

                       ""))

         (hnumber  (let loop ((numlist hnr) (number defnum) 

                              (sep (if (equal? defnum "") "" ".")))

                     (if (null? numlist)

                         number

                         (loop (cdr numlist) 

                               (string-append number

                                              sep

                                              (number->string (car numlist)))

                               "."))))

         (cnumber  (child-number (parent node)))

         (number   (string-append hnumber 

                                  (if (equal? hnumber "")

                                      ""

                                      ".")

                                  (number->string cnumber))))

-->

  <xsl:choose>

    <xsl:when test="$deflabel = 'qanda'">

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

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

          <xsl:choose>

            <xsl:when test="local-name(.) = 'question'">question</xsl:when>

            <xsl:when test="local-name(.) = 'answer'">answer</xsl:when>

            <xsl:when test="local-name(.) = 'qandadiv'">qandadiv</xsl:when>

            <xsl:otherwise>qandaset</xsl:otherwise>

          </xsl:choose>

        </xsl:with-param>

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="$deflabel = 'label'">

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

    </xsl:when>

                    and local-name(.) = 'question'">

                           mode="number"/>

      <xsl:choose>

        <xsl:when test="ancestor::qandadiv">

                               mode="number"/>

                               mode="number"/>

        </xsl:when>

        <xsl:otherwise>

                               mode="number"/>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:otherwise>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template match="qandaset" mode="number">

</xsl:template>

<xsl:template match="qandadiv" mode="number">

  <xsl:number level="multiple" from="qandaset" format="1."/>

</xsl:template>

<xsl:template match="qandaentry" mode="number">

  <xsl:choose>

    <xsl:when test="ancestor::qandadiv">

      <xsl:number level="single" from="qandadiv" format="1."/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:number level="single" from="qandaset" format="1."/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

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

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

  <xsl:choose>

    <xsl:when test="$object/@id">

      <xsl:value-of select="$object/@id"/>

    </xsl:when>

    <xsl:when test="$object/@xml:id">

      <xsl:value-of select="$object/@xml:id"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:value-of select="generate-id($object)"/>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="person.name">

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

  <xsl:variable name="style">

    <xsl:choose>

      <xsl:when test="$node/@role">

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

      </xsl:when>

      <xsl:otherwise>

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

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

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

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$node/personname">

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

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

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="local-name($node)='corpauthor'">

      <xsl:apply-templates select="$node"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:choose>

        <xsl:when test="$node/self::personname and not($node/firstname or $node/honorific or $node/lineage or $node/othername or $node/surname)">

          <xsl:apply-templates select="$node/node()"/>

        </xsl:when>

        <xsl:when test="$style = 'family-given'">

          <xsl:call-template name="person.name.family-given">

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

          </xsl:call-template>

        </xsl:when>

        <xsl:when test="$style = 'last-first'">

          <xsl:call-template name="person.name.last-first">

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

          </xsl:call-template>

        </xsl:when>

        <xsl:otherwise>

          <xsl:call-template name="person.name.first-last">

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

          </xsl:call-template>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="person.name.family-given">

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

  <xsl:apply-templates select="$node//surname[1]"/>

  <xsl:if test="$node//surname and $node//firstname">

    <xsl:text> </xsl:text>

  </xsl:if>

  <xsl:apply-templates select="$node//firstname[1]"/>

  <xsl:text> [FAMILY Given]</xsl:text>

</xsl:template>

<xsl:template name="person.name.last-first">

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

  <xsl:apply-templates select="$node//surname[1]"/>

  <xsl:if test="$node//surname and $node//firstname">

    <xsl:text>, </xsl:text>

  </xsl:if>

  <xsl:apply-templates select="$node//firstname[1]"/>

</xsl:template>

<xsl:template name="person.name.first-last">

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

  <xsl:if test="$node//honorific">

    <xsl:apply-templates select="$node//honorific[1]"/>

    <xsl:value-of select="$punct.honorific"/>

  </xsl:if>

  <xsl:if test="$node//firstname">

    <xsl:if test="$node//honorific">

      <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:apply-templates select="$node//firstname[1]"/>

  </xsl:if>

  <xsl:if test="$node//othername and $author.othername.in.middle != 0">

    <xsl:if test="$node//honorific or $node//firstname">

      <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:apply-templates select="$node//othername[1]"/>

  </xsl:if>

  <xsl:if test="$node//surname">

                  or ($node//othername and $author.othername.in.middle != 0)">

      <xsl:text> </xsl:text>

    </xsl:if>

    <xsl:apply-templates select="$node//surname[1]"/>

  </xsl:if>

  <xsl:if test="$node//lineage">

    <xsl:text>, </xsl:text>

    <xsl:apply-templates select="$node//lineage[1]"/>

  </xsl:if>

</xsl:template>

<xsl:template name="person.name.list">

       the current element. The current element must contain one or

       more AUTHORs, CORPAUTHORs, OTHERCREDITs, and/or EDITORs.

       John Doe

     or

       John Doe and Jane Doe

     or

       John Doe, Jane Doe, and A. Nonymous

  -->

             select="author|corpauthor|othercredit|editor"/>

  <xsl:param name="person.count" select="count($person.list)"/>

  <xsl:param name="count" select="1"/>

  <xsl:choose>

    <xsl:when test="$count > $person.count"></xsl:when>

    <xsl:otherwise>

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

        <xsl:with-param name="node" select="$person.list[position()=$count]"/>

      </xsl:call-template>

      <xsl:choose>

        <xsl:when test="$person.count = 2 and $count = 1">

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

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

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

          </xsl:call-template>

        </xsl:when>

        <xsl:when test="$person.count > 2 and $count+1 = $person.count">

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

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

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

          </xsl:call-template>

        </xsl:when>

        <xsl:when test="$count < $person.count">

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

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

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

          </xsl:call-template>

        </xsl:when>

      </xsl:choose>

      <xsl:call-template name="person.name.list">

        <xsl:with-param name="person.list" select="$person.list"/>

        <xsl:with-param name="person.count" select="$person.count"/>

        <xsl:with-param name="count" select="$count+1"/>

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

     documentation for DocBook V3.0

-->

<xsl:variable name="arg.choice.opt.open.str">[</xsl:variable>

<xsl:variable name="arg.choice.opt.close.str">]</xsl:variable>

<xsl:variable name="arg.choice.req.open.str">{</xsl:variable>

<xsl:variable name="arg.choice.req.close.str">}</xsl:variable>

<xsl:variable name="arg.choice.plain.open.str"><xsl:text> </xsl:text></xsl:variable>

<xsl:variable name="arg.choice.plain.close.str"><xsl:text> </xsl:text></xsl:variable>

<xsl:variable name="arg.choice.def.open.str">[</xsl:variable>

<xsl:variable name="arg.choice.def.close.str">]</xsl:variable>

<xsl:variable name="arg.rep.repeat.str">...</xsl:variable>

<xsl:variable name="arg.rep.norepeat.str"></xsl:variable>

<xsl:variable name="arg.rep.def.str"></xsl:variable>

<xsl:variable name="arg.or.sep"> | </xsl:variable>

<xsl:variable name="cmdsynopsis.hanging.indent">4pi</xsl:variable>

<xsl:template name="xref.g.subst">

  <xsl:param name="string"></xsl:param>

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

  <xsl:variable name="subst">%g</xsl:variable>

  <xsl:choose>

    <xsl:when test="contains($string, $subst)">

      <xsl:value-of select="substring-before($string, $subst)"/>

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

        <xsl:with-param name="element.name" select="local-name($target)"/>

      </xsl:call-template>

      <xsl:call-template name="xref.g.subst">

                        select="substring-after($string, $subst)"/>

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

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="xref.t.subst">

  <xsl:param name="string"></xsl:param>

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

  <xsl:variable name="subst">%t</xsl:variable>

  <xsl:choose>

    <xsl:when test="contains($string, $subst)">

      <xsl:call-template name="xref.g.subst">

                        select="substring-before($string, $subst)"/>

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

      </xsl:call-template>

      <xsl:call-template name="title.xref">

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

      </xsl:call-template>

      <xsl:call-template name="xref.t.subst">

                        select="substring-after($string, $subst)"/>

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

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="xref.g.subst">

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

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

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="xref.n.subst">

  <xsl:param name="string"></xsl:param>

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

  <xsl:variable name="subst">%n</xsl:variable>

  <xsl:choose>

    <xsl:when test="contains($string, $subst)">

      <xsl:call-template name="xref.t.subst">

                        select="substring-before($string, $subst)"/>

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

      </xsl:call-template>

      <xsl:call-template name="number.xref">

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

      </xsl:call-template>

      <xsl:call-template name="xref.t.subst">

                        select="substring-after($string, $subst)"/>

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

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="xref.t.subst">

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

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

      </xsl:call-template>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="subst.xref.text">

  <xsl:param name="xref.text"></xsl:param>

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

  <xsl:call-template name="xref.n.subst">

    <xsl:with-param name="string" select="$xref.text"/>

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

  </xsl:call-template>

</xsl:template>

-->

<xsl:template name="filename-basename">

  <xsl:param name="filename"></xsl:param>

  <xsl:param name="recurse" select="false()"/>

  <xsl:choose>

    <xsl:when test="substring-after($filename, '/') != ''">

      <xsl:call-template name="filename-basename">

                        select="substring-after($filename, '/')"/>

        <xsl:with-param name="recurse" select="true()"/>

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="filename-extension">

  <xsl:param name="filename"></xsl:param>

  <xsl:param name="recurse" select="false()"/>

  <xsl:variable name="basefn">

    <xsl:choose>

      <xsl:when test="$recurse">

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

      </xsl:when>

      <xsl:otherwise>

        <xsl:call-template name="filename-basename">

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

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="substring-after($basefn, '.') != ''">

      <xsl:call-template name="filename-extension">

                        select="substring-after($basefn, '.')"/>

        <xsl:with-param name="recurse" select="true()"/>

      </xsl:call-template>

    </xsl:when>

    <xsl:when test="$recurse">

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

    </xsl:when>

    <xsl:otherwise></xsl:otherwise>

  </xsl:choose>

</xsl:template>

<doc:template name="select.mediaobject" xmlns="">

<refpurpose>Selects and processes an appropriate media object from a list</refpurpose>

<refdescription id="select.mediaobject-desc">

<para>This template takes a list of media objects (usually the

children of a mediaobject or inlinemediaobject) and processes

the "right" object.</para>

<para>This template relies on a template named 

"select.mediaobject.index" to determine which object

in the list is appropriate.</para>

<para>If no acceptable object is located, nothing happens.</para>

</refdescription>

<refparameter id="select.mediaobject-params">