The DoCookBook

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <xsl:stylesheet version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  4   xmlns="http://docbook.org/ns/docbook">
      
  6   <xsl:import href="copy.xsl"/>
      <xsl:output indent="yes"/>
  8 
      <xsl:strip-space elements="*"/>
 10   <xsl:preserve-space elements="d:screen d:literallayout
        d:programlisting d:address"/>
 12 </xsl:stylesheet>

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <!DOCTYPE xsl:stylesheet 
    [
  4  <!ENTITY db "http://docbook.sourceforge.net/release/xsl-ns/current"> 
    ]>
  6 <xsl:stylesheet version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  8   xmlns:d="http://docbook.org/ns/docbook"
      xmlns:exsl="http://exslt.org/common"
 10   xmlns:xi="http://www.w3.org/2001/XInclude"
      extension-element-prefixes="exsl">
 12 
      <xsl:import href="chunker.xsl"/>
 14   <xsl:import href="copy.xsl"/>
      <xsl:output indent="yes"/>
 16 
    
 18   <xsl:param name="base.dir" select="'out/'"/>
      <xsl:param name="use.id.as.filename" select="0"/>
 20   <xsl:param name="rootid"/>
    
 22   <xsl:param name="dbsplit.root.filename">Index</xsl:param>
      <xsl:param name="dbsplit.ext">.xml</xsl:param>
 24   <xsl:param name="dbsplit.chunk.depth" select="2"/>
    
 26   <xsl:template name="object.id">
        <xsl:param name="object" select="."/>
 28     <xsl:choose>
          <xsl:when test="$object/@id">
 30         <xsl:value-of select="$object/@id"/>
          </xsl:when>
 32       <xsl:when test="$object/@xml:id">
            <xsl:value-of select="$object/@xml:id"/>
 34       </xsl:when>
          <xsl:otherwise>
 36         <xsl:value-of select="generate-id($object)"/>
          </xsl:otherwise>
 38     </xsl:choose>
      </xsl:template>
 40 
      <xsl:template match="*" mode="recursive-chunk-filename">
 42     <xsl:param name="recursive" select="false()"/>
        <xsl:variable name="filename">
 44       <xsl:choose>
            <!-- if this is the root element, use the dbsplit.root.filename -->
 46         <xsl:when test="not(parent::*) and $dbsplit.root.filename != ''">
              <xsl:value-of select="$dbsplit.root.filename"/>
 48           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:when>
 50         <!-- Special case -->
            <xsl:when
 52           test="self::d:legalnotice and not($generate.legalnotice.link = 0)">
              <xsl:choose>
 54             <xsl:when
                  test="(@id or @xml:id) and not($use.id.as.filename = 0)">
 56               <!-- * if this legalnotice has an ID, then go ahead and use -->
                  <!-- * just the value of that ID as the basename for the file -->
 58               <!-- * (that is, without prepending an "ln-" too it) -->
                  <xsl:value-of select="(@id|@xml:id)[1]"/>
 60               <xsl:value-of select="$dbsplit.ext"/>
                </xsl:when>
 62             <xsl:otherwise>
                  <!-- * otherwise, if this legalnotice does not have an ID, -->
 64               <!-- * then we generate an ID... -->
                  <xsl:variable name="id">
 66                 <xsl:call-template name="object.id"/>
                  </xsl:variable>
 68               <!-- * ...and then we take that generated ID, prepend an -->
                  <!-- * "ln-" to it, and use that as the basename for the file -->
 70               <xsl:value-of select="concat('ln-',$id,$dbsplit.ext)"/>
                </xsl:otherwise>
 72           </xsl:choose>
            </xsl:when>
 74         <!-- if there's no dbhtml filename, and if we're to use IDs as -->
            <!-- filenames, then use the ID to generate the filename. -->
 76         <xsl:when test="(@id or @xml:id) and $use.id.as.filename != 0">
              <xsl:value-of select="(@id|@xml:id)[1]"/>
 78           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:when>
 80         <xsl:otherwise/>
          </xsl:choose>
 82     </xsl:variable>
    
 84     <xsl:choose>
          <xsl:when test="not($recursive) and $filename != ''">
 86         <!-- if this chunk has an explicit name, use it -->
            <xsl:value-of select="$filename"/>
 88       </xsl:when>
    
 90       <xsl:when test="self::d:set">
            <xsl:value-of select="$dbsplit.root.filename"/>
 92         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
 94         </xsl:if>
          </xsl:when>
 96 
          <xsl:when test="self::d:book">
 98         <xsl:text>bk</xsl:text>
            <xsl:number level="any" format="01"/>
100         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
102         </xsl:if>
          </xsl:when>
104 
          <xsl:when test="self::d:article">
106         <xsl:if test="/d:set">
              <!-- in a set, make sure we inherit the right book info... -->
108           <xsl:apply-templates mode="recursive-chunk-filename"
                select="parent::*">
110             <xsl:with-param name="recursive" select="true()"/>
              </xsl:apply-templates>
112         </xsl:if>
    
114         <xsl:text>ar</xsl:text>
            <xsl:number level="any" format="01" from="d:book"/>
116         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
118         </xsl:if>
          </xsl:when>
120 
          <xsl:when test="self::d:preface">
122         <xsl:if test="/d:set">
              <!-- in a set, make sure we inherit the right book info... -->
124           <xsl:apply-templates mode="recursive-chunk-filename"
                select="parent::*">
126             <xsl:with-param name="recursive" select="true()"/>
              </xsl:apply-templates>
128         </xsl:if>
    
130         <xsl:text>pr</xsl:text>
            <xsl:number level="any" format="01" from="d:book"/>
132         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
134         </xsl:if>
          </xsl:when>
136 
          <xsl:when test="self::d:chapter">
138         <xsl:if test="/d:set">
              <!-- in a set, make sure we inherit the right book info... -->
140           <xsl:apply-templates mode="recursive-chunk-filename"
                select="parent::*">
142             <xsl:with-param name="recursive" select="true()"/>
              </xsl:apply-templates>
144         </xsl:if>
    
146         <xsl:text>ch</xsl:text>
            <xsl:number level="any" format="01" from="d:book"/>
148         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
150         </xsl:if>
          </xsl:when>
152 
          <xsl:when test="self::d:appendix">
154         <xsl:if test="/d:set">
              <!-- in a set, make sure we inherit the right book info... -->
156           <xsl:apply-templates mode="recursive-chunk-filename"
                select="parent::*">
158             <xsl:with-param name="recursive" select="true()"/>
              </xsl:apply-templates>
160         </xsl:if>
    
162         <xsl:text>ap</xsl:text>
            <xsl:number level="any" format="a" from="d:book"/>
164         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
166         </xsl:if>
          </xsl:when>
168 
          <xsl:when test="self::d:part">
170         <xsl:choose>
              <xsl:when test="/d:set">
172             <!-- in a set, make sure we inherit the right book info... -->
                <xsl:apply-templates mode="recursive-chunk-filename"
174               select="parent::*">
                  <xsl:with-param name="recursive" select="true()"/>
176             </xsl:apply-templates>
              </xsl:when>
178           <xsl:otherwise> </xsl:otherwise>
            </xsl:choose>
180 
            <xsl:text>pt</xsl:text>
182         <xsl:number level="any" format="01" from="d:book"/>
            <xsl:if test="not($recursive)">
184           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:if>
186       </xsl:when>
    
188       <xsl:when test="self::d:reference">
            <xsl:choose>
190           <xsl:when test="/d:set">
                <!-- in a set, make sure we inherit the right book info... -->
192             <xsl:apply-templates mode="recursive-chunk-filename"
                  select="parent::*">
194               <xsl:with-param name="recursive" select="true()"/>
                </xsl:apply-templates>
196           </xsl:when>
              <xsl:otherwise> </xsl:otherwise>
198         </xsl:choose>
    
200         <xsl:text>rn</xsl:text>
            <xsl:number level="any" format="01" from="d:book"/>
202         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
204         </xsl:if>
          </xsl:when>
206 
          <xsl:when test="self::d:refentry">
208         <xsl:choose>
              <xsl:when test="parent::d:reference">
210             <xsl:apply-templates mode="recursive-chunk-filename"
                  select="parent::*">
212               <xsl:with-param name="recursive" select="true()"/>
                </xsl:apply-templates>
214           </xsl:when>
              <xsl:otherwise>
216             <xsl:if test="/d:set">
                  <!-- in a set, make sure we inherit the right book info... -->
218               <xsl:apply-templates mode="recursive-chunk-filename"
                    select="parent::*">
220                 <xsl:with-param name="recursive" select="true()"/>
                  </xsl:apply-templates>
222             </xsl:if>
              </xsl:otherwise>
224         </xsl:choose>
    
226         <xsl:text>re</xsl:text>
            <xsl:number level="any" format="01" from="d:book"/>
228         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
230         </xsl:if>
          </xsl:when>
232 
          <xsl:when test="self::d:colophon">
234         <xsl:choose>
              <xsl:when test="/d:set">
236             <!-- in a set, make sure we inherit the right book info... -->
                <xsl:apply-templates mode="recursive-chunk-filename"
238               select="parent::*">
                  <xsl:with-param name="recursive" select="true()"/>
240             </xsl:apply-templates>
              </xsl:when>
242           <xsl:otherwise> </xsl:otherwise>
            </xsl:choose>
244 
            <xsl:text>co</xsl:text>
246         <xsl:number level="any" format="01" from="d:book"/>
            <xsl:if test="not($recursive)">
248           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:if>
250       </xsl:when>
    
252       <xsl:when test="self::d:sect1 or self::d:sect2 or self::d:sect3 or 
                          self::d:sect4 or self::d:sect5 or self::d:section">
254         <xsl:apply-templates mode="recursive-chunk-filename"
              select="parent::*">
256           <xsl:with-param name="recursive" select="true()"/>
            </xsl:apply-templates>
258         <xsl:text>s</xsl:text>
            <xsl:number format="01"/>
260         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
262         </xsl:if>
          </xsl:when>
264 
          <xsl:when test="self::d:bibliography">
266         <xsl:choose>
              <xsl:when test="/d:set">
268             <!-- in a set, make sure we inherit the right book info... -->
                <xsl:apply-templates mode="recursive-chunk-filename"
270               select="parent::*">
                  <xsl:with-param name="recursive" select="true()"/>
272             </xsl:apply-templates>
              </xsl:when>
274           <xsl:otherwise> </xsl:otherwise>
            </xsl:choose>
276 
            <xsl:text>bi</xsl:text>
278         <xsl:number level="any" format="01" from="d:book"/>
            <xsl:if test="not($recursive)">
280           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:if>
282       </xsl:when>
    
284       <xsl:when test="self::d:glossary">
            <xsl:choose>
286           <xsl:when test="/d:set">
                <!-- in a set, make sure we inherit the right book info... -->
288             <xsl:apply-templates mode="recursive-chunk-filename"
                  select="parent::*">
290               <xsl:with-param name="recursive" select="true()"/>
                </xsl:apply-templates>
292           </xsl:when>
              <xsl:otherwise> </xsl:otherwise>
294         </xsl:choose>
    
296         <xsl:text>go</xsl:text>
            <xsl:number level="any" format="01" from="d:book"/>
298         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
300         </xsl:if>
          </xsl:when>
302 
          <xsl:when test="self::d:index">
304         <xsl:choose>
              <xsl:when test="/d:set">
306             <!-- in a set, make sure we inherit the right book info... -->
                <xsl:apply-templates mode="recursive-chunk-filename"
308               select="parent::*">
                  <xsl:with-param name="recursive" select="true()"/>
310             </xsl:apply-templates>
              </xsl:when>
312           <xsl:otherwise> </xsl:otherwise>
            </xsl:choose>
314 
            <xsl:text>ix</xsl:text>
316         <xsl:number level="any" format="01" from="d:book"/>
            <xsl:if test="not($recursive)">
318           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:if>
320       </xsl:when>
    
322       <xsl:when test="self::d:setindex">
            <xsl:text>si</xsl:text>
324         <xsl:number level="any" format="01" from="d:set"/>
            <xsl:if test="not($recursive)">
326           <xsl:value-of select="$dbsplit.ext"/>
            </xsl:if>
328       </xsl:when>
    
330       <xsl:otherwise>
            <xsl:text>chunk-filename-error-</xsl:text>
332         <xsl:value-of select="name(.)"/>
            <xsl:number level="any" format="01" from="d:set"/>
334         <xsl:if test="not($recursive)">
              <xsl:value-of select="$dbsplit.ext"/>
336         </xsl:if>
          </xsl:otherwise>
338     </xsl:choose>
      </xsl:template>
340 
      <xsl:template name="generate-filename">
342     <xsl:apply-templates select="." mode="recursive-chunk-filename"/>
      </xsl:template>
344 
      <xsl:template name="generate-content">
346     <xsl:variable name="filename">
          <xsl:call-template name="make-relative-filename">
348         <xsl:with-param name="base.dir" select="$base.dir"/>
            <xsl:with-param name="base.name">
350            <xsl:call-template name="generate-filename"/>
            </xsl:with-param>
352       </xsl:call-template>
        </xsl:variable>
354     <xsl:variable name="depth" select="count(ancestor::*)"/>
        
356     <!--<xsl:message>generate-content:
          name: <xsl:value-of select="name()"/>
358       filename: <xsl:value-of select="$filename"/>
          depth: <xsl:value-of select="$depth"/>
360       test: <xsl:value-of select="$depth >= $dbsplit.chunk.depth"/>
        </xsl:message>-->
362     
        <xsl:choose>
364       <xsl:when test="$depth &lt;= $dbsplit.chunk.depth">
            <xi:include href="{$filename}"/>
366         <xsl:call-template name="write.xml.chunk">
              <xsl:with-param name="filename" select="$filename"/>
368           <xsl:with-param name="content">
                <xsl:copy-of select="preceding-sibling::processing-instruction()|
370                                  preceding-sibling::comment()"/>
                <xsl:copy>
372               <xsl:apply-templates/>
                </xsl:copy>
374           </xsl:with-param>
            </xsl:call-template>
376       </xsl:when>
          <xsl:otherwise>
378         <xsl:copy>
              <xsl:apply-templates/>
380         </xsl:copy>
          </xsl:otherwise>
382     </xsl:choose>
      </xsl:template>
384 
      <xsl:template
386     match="d:acknowledgements|d:appendix|d:article|
               d:bibliography|
388            d:chapter|d:colophon|d:dedication|d:glossary|
               d:part|d:preface|d:reference|d:topic|
390            d:sect1|d:section[not(parent::d:section)]">
        <xsl:call-template name="generate-content"/>
392   </xsl:template>
    
394 </xsl:stylesheet>

  1 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  2   xmlns:saxon="http://icl.com/saxon"
      xmlns:lxslt="http://xml.apache.org/xslt"
  4   xmlns:redirect="http://xml.apache.org/xalan/redirect"
      xmlns:exsl="http://exslt.org/common"
  6   xmlns="http://www.w3.org/1999/xhtml" version="1.0"
      exclude-result-prefixes="saxon lxslt redirect exsl"
  8   extension-element-prefixes="saxon redirect lxslt exsl">
    
 10   <xsl:param name="chunker.output.method" select="'xml'"/>
      <xsl:param name="chunker.output.encoding" select="'UTF-8'"/>
 12   <xsl:param name="chunker.output.indent" select="'no'"/>
      <xsl:param name="chunker.output.omit-xml-declaration" select="'no'"/>
 14   <xsl:param name="chunker.output.standalone" select="'no'"/>
      <xsl:param name="chunker.output.doctype-public" select="''"/>
 16   <xsl:param name="chunker.output.doctype-system" select="''"/>
      <xsl:param name="chunker.output.media-type" select="''"/>
 18   <xsl:param name="chunker.output.cdata-section-elements" select="''"/>
      <xsl:param name="chunker.output.quiet" select="0"/>
 20 
      <xsl:param name="saxon.character.representation"
 22     select="'entity;decimal'"/>
    
 24   <xsl:template name="make-relative-filename">
        <xsl:param name="base.dir" select="'./'"/>
 26     <xsl:param name="base.name" select="''"/>
    
 28     <xsl:choose>
          <!-- put Saxon first to work around a bug in libxslt -->
 30       <xsl:when test="element-available('saxon:output')">
            <!-- Saxon doesn't make the chunks relative -->
 32         <xsl:value-of select="concat($base.dir,$base.name)"/>
          </xsl:when>
 34       <xsl:when test="element-available('exsl:document')">
            <!-- EXSL document does make the chunks relative, I think -->
 36         <xsl:choose>
              <xsl:when test="count(parent::*) = 0">
 38             <xsl:value-of select="concat($base.dir,$base.name)"/>
              </xsl:when>
 40           <xsl:otherwise>
                <xsl:value-of select="$base.name"/>
 42           </xsl:otherwise>
            </xsl:choose>
 44       </xsl:when>
          <xsl:when test="element-available('redirect:write')">
 46         <!-- Xalan doesn't make the chunks relative -->
            <xsl:value-of select="concat($base.dir,$base.name)"/>
 48       </xsl:when>
          <xsl:otherwise>
 50         <xsl:message terminate="yes">
              <xsl:text>Don't know how to chunk with </xsl:text>
 52           <xsl:value-of select="system-property('xsl:vendor')"/>
            </xsl:message>
 54       </xsl:otherwise>
        </xsl:choose>
 56   </xsl:template>
    
 58   <xsl:template name="write.chunk">
        <xsl:param name="filename" select="''"/>
 60     <xsl:param name="quiet" select="$chunker.output.quiet"/>
        <xsl:param name="suppress-context-node-name" select="0"/>
 62     <xsl:param name="message-prolog"/>
        <xsl:param name="message-epilog"/>
 64 
        <xsl:param name="method" select="$chunker.output.method"/>
 66     <xsl:param name="encoding" select="$chunker.output.encoding"/>
        <xsl:param name="indent" select="$chunker.output.indent"/>
 68     <xsl:param name="omit-xml-declaration"
          select="$chunker.output.omit-xml-declaration"/>
 70     <xsl:param name="standalone" select="$chunker.output.standalone"/>
        <xsl:param name="doctype-public"
 72       select="$chunker.output.doctype-public"/>
        <xsl:param name="doctype-system"
 74       select="$chunker.output.doctype-system"/>
        <xsl:param name="media-type" select="$chunker.output.media-type"/>
 76     <xsl:param name="cdata-section-elements"
          select="$chunker.output.cdata-section-elements"/>
 78 
        <xsl:param name="content"/>
 80 
        <xsl:if test="$quiet = 0">
 82       <xsl:message>
            <xsl:if test="not($message-prolog = '')">
 84           <xsl:value-of select="$message-prolog"/>
            </xsl:if>
 86         <xsl:text>Writing </xsl:text>
            <xsl:value-of select="$filename"/>
 88         <xsl:if test="name(.) != '' and $suppress-context-node-name = 0">
              <xsl:text> for </xsl:text>
 90           <xsl:value-of select="name(.)"/>
              <xsl:if test="@id or @xml:id">
 92             <xsl:text>(</xsl:text>
                <xsl:value-of select="(@id|@xml:id)[1]"/>
 94             <xsl:text>)</xsl:text>
              </xsl:if>
 96         </xsl:if>
            <xsl:if test="not($message-epilog = '')">
 98           <xsl:value-of select="$message-epilog"/>
            </xsl:if>
100       </xsl:message>
        </xsl:if>
102 
        <xsl:choose>
104       <xsl:when test="element-available('exsl:document')">
            <xsl:choose>
106           <!-- Handle the permutations ... -->
              <xsl:when test="$media-type != ''">
108             <xsl:choose>
                  <xsl:when
110                 test="$doctype-public != '' and $doctype-system != ''">
                    <exsl:document href="{$filename}" method="{$method}"
112                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
114                   cdata-section-elements="{$cdata-section-elements}"
                      media-type="{$media-type}"
116                   doctype-public="{$doctype-public}"
                      doctype-system="{$doctype-system}"
118                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
120                 </exsl:document>
                  </xsl:when>
122               <xsl:when
                    test="$doctype-public != '' and $doctype-system = ''">
124                 <exsl:document href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
126                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
128                   media-type="{$media-type}"
                      doctype-public="{$doctype-public}"
130                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
132                 </exsl:document>
                  </xsl:when>
134               <xsl:when
                    test="$doctype-public = '' and $doctype-system != ''">
136                 <exsl:document href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
138                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
140                   media-type="{$media-type}"
                      doctype-system="{$doctype-system}"
142                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
144                 </exsl:document>
                  </xsl:when>
146               <xsl:otherwise>
                    <!-- $doctype-public = '' and $doctype-system = ''"> -->
148                 <exsl:document href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
150                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
152                   media-type="{$media-type}" standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
154                 </exsl:document>
                  </xsl:otherwise>
156             </xsl:choose>
              </xsl:when>
158           <xsl:otherwise>
                <xsl:choose>
160               <xsl:when
                    test="$doctype-public != '' and $doctype-system != ''">
162                 <exsl:document href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
164                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
166                   doctype-public="{$doctype-public}"
                      doctype-system="{$doctype-system}"
168                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
170                 </exsl:document>
                  </xsl:when>
172               <xsl:when
                    test="$doctype-public != '' and $doctype-system = ''">
174                 <exsl:document href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
176                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
178                   doctype-public="{$doctype-public}"
                      standalone="{$standalone}">
180                   <xsl:copy-of select="$content"/>
                    </exsl:document>
182               </xsl:when>
                  <xsl:when
184                 test="$doctype-public = '' and $doctype-system != ''">
                    <exsl:document href="{$filename}" method="{$method}"
186                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
188                   cdata-section-elements="{$cdata-section-elements}"
                      doctype-system="{$doctype-system}"
190                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
192                 </exsl:document>
                  </xsl:when>
194               <xsl:otherwise>
                    <!-- $doctype-public = '' and $doctype-system = ''"> -->
196                 <exsl:document href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
198                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
200                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
202                 </exsl:document>
                  </xsl:otherwise>
204             </xsl:choose>
              </xsl:otherwise>
206         </xsl:choose>
          </xsl:when>
208 
          <xsl:when test="element-available('saxon:output')">
210         <xsl:choose>
              <!-- Handle the permutations ... -->
212           <xsl:when test="$media-type != ''">
                <xsl:choose>
214               <xsl:when
                    test="$doctype-public != '' and $doctype-system != ''">
216                 <saxon:output
                      saxon:character-representation="{$saxon.character.representation}"
218                   href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
220                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
222                   media-type="{$media-type}"
                      doctype-public="{$doctype-public}"
224                   doctype-system="{$doctype-system}"
                      standalone="{$standalone}">
226                   <xsl:copy-of select="$content"/>
                    </saxon:output>
228               </xsl:when>
                  <xsl:when
230                 test="$doctype-public != '' and $doctype-system = ''">
                    <saxon:output
232                   saxon:character-representation="{$saxon.character.representation}"
                      href="{$filename}" method="{$method}"
234                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
236                   cdata-section-elements="{$cdata-section-elements}"
                      media-type="{$media-type}"
238                   doctype-public="{$doctype-public}"
                      standalone="{$standalone}">
240                   <xsl:copy-of select="$content"/>
                    </saxon:output>
242               </xsl:when>
                  <xsl:when
244                 test="$doctype-public = '' and $doctype-system != ''">
                    <saxon:output
246                   saxon:character-representation="{$saxon.character.representation}"
                      href="{$filename}" method="{$method}"
248                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
250                   cdata-section-elements="{$cdata-section-elements}"
                      media-type="{$media-type}"
252                   doctype-system="{$doctype-system}"
                      standalone="{$standalone}">
254                   <xsl:copy-of select="$content"/>
                    </saxon:output>
256               </xsl:when>
                  <xsl:otherwise>
258                 <!-- $doctype-public = '' and $doctype-system = ''"> -->
                    <saxon:output
260                   saxon:character-representation="{$saxon.character.representation}"
                      href="{$filename}" method="{$method}"
262                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
264                   cdata-section-elements="{$cdata-section-elements}"
                      media-type="{$media-type}" standalone="{$standalone}">
266                   <xsl:copy-of select="$content"/>
                    </saxon:output>
268               </xsl:otherwise>
                </xsl:choose>
270           </xsl:when>
              <xsl:otherwise>
272             <xsl:choose>
                  <xsl:when
274                 test="$doctype-public != '' and $doctype-system != ''">
                    <saxon:output
276                   saxon:character-representation="{$saxon.character.representation}"
                      href="{$filename}" method="{$method}"
278                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
280                   cdata-section-elements="{$cdata-section-elements}"
                      doctype-public="{$doctype-public}"
282                   doctype-system="{$doctype-system}"
                      standalone="{$standalone}">
284                   <xsl:copy-of select="$content"/>
                    </saxon:output>
286               </xsl:when>
                  <xsl:when
288                 test="$doctype-public != '' and $doctype-system = ''">
                    <saxon:output
290                   saxon:character-representation="{$saxon.character.representation}"
                      href="{$filename}" method="{$method}"
292                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
294                   cdata-section-elements="{$cdata-section-elements}"
                      doctype-public="{$doctype-public}"
296                   standalone="{$standalone}">
                      <xsl:copy-of select="$content"/>
298                 </saxon:output>
                  </xsl:when>
300               <xsl:when
                    test="$doctype-public = '' and $doctype-system != ''">
302                 <saxon:output
                      saxon:character-representation="{$saxon.character.representation}"
304                   href="{$filename}" method="{$method}"
                      encoding="{$encoding}" indent="{$indent}"
306                   omit-xml-declaration="{$omit-xml-declaration}"
                      cdata-section-elements="{$cdata-section-elements}"
308                   doctype-system="{$doctype-system}"
                      standalone="{$standalone}">
310                   <xsl:copy-of select="$content"/>
                    </saxon:output>
312               </xsl:when>
                  <xsl:otherwise>
314                 <!-- $doctype-public = '' and $doctype-system = ''"> -->
                    <saxon:output
316                   saxon:character-representation="{$saxon.character.representation}"
                      href="{$filename}" method="{$method}"
318                   encoding="{$encoding}" indent="{$indent}"
                      omit-xml-declaration="{$omit-xml-declaration}"
320                   cdata-section-elements="{$cdata-section-elements}"
                      standalone="{$standalone}">
322                   <xsl:copy-of select="$content"/>
                    </saxon:output>
324               </xsl:otherwise>
                </xsl:choose>
326           </xsl:otherwise>
            </xsl:choose>
328       </xsl:when>
    
330       <xsl:when test="element-available('redirect:write')">
            <!-- Xalan uses redirect -->
332         <redirect:write file="{$filename}">
              <xsl:copy-of select="$content"/>
334         </redirect:write>
          </xsl:when>
336 
          <xsl:otherwise>
338         <!-- it doesn't matter since we won't be making chunks... -->
            <xsl:message terminate="yes">
340           <xsl:text>Can't make chunks with </xsl:text>
              <xsl:value-of select="system-property('xsl:vendor')"/>
342           <xsl:text>'s processor.</xsl:text>
            </xsl:message>
344       </xsl:otherwise>
        </xsl:choose>
346   </xsl:template>
    
348   <xsl:template name="write.xml.chunk">
        <xsl:param name="filename" select="''"/>
350     <xsl:param name="quiet" select="$chunker.output.quiet"/>
        <xsl:param name="suppress-context-node-name" select="0"/>
352     <xsl:param name="message-prolog"/>
        <xsl:param name="message-epilog"/>
354     <xsl:param name="method" select="'xml'"/>
        <xsl:param name="encoding" select="$chunker.output.encoding"/>
356     <xsl:param name="media-type" select="$chunker.output.media-type"/>
        <xsl:param name="content"/>
358     <xsl:call-template name="write.chunk">
          <xsl:with-param name="filename" select="$filename"/>
360       <xsl:with-param name="quiet" select="$quiet"/>
          <xsl:with-param name="suppress-context-node-name"
362         select="$suppress-context-node-name"/>
          <xsl:with-param name="message-prolog" select="$message-prolog"/>
364       <xsl:with-param name="message-epilog" select="$message-epilog"/>
          <xsl:with-param name="method" select="$method"/>
366       <xsl:with-param name="encoding" select="$encoding"/>
          <xsl:with-param name="indent" select="'yes'"/>
368       <xsl:with-param name="omit-xml-declaration" select="'no'"/>
          <xsl:with-param name="standalone" select="'no'"/>
370       <xsl:with-param name="doctype-public"/>
          <xsl:with-param name="doctype-system"/>
372       <xsl:with-param name="media-type" select="$media-type"/>
          <xsl:with-param name="cdata-section-elements"/>
374       <xsl:with-param name="content" select="$content"/>
        </xsl:call-template>
376   </xsl:template>
    </xsl:stylesheet>

TBD

  1 <log>
  2   <logentry revision="69"
        node="dfadd024594c4083362fe6919264362803dcd285">
  4     <tag>tip</tag>
        <author email="tux@example.de">Tux Penguin</author>
  6     <date>2011-05-22T01:56:21+02:00</date>
        <msg xml:space="preserve">Corrected xml:id attribute</msg>
  8     <paths>
          <path action="M">xml/structure/topic.extract-element.xml</path>
 10     </paths>
      </logentry>
 12   <logentry revision="68"
        node="833287df8943d0bab5ec65ec8aafe5bc42002289">
 14     <author email="wilber@example.de">Wilber Gimp</author>
        <date>2011-05-22T01:56:03+02:00</date>
 16     <msg xml:space="preserve">Changed chapter title</msg>
        <paths>
 18       <path action="M">xml/structure/topic.revision-list.xml</path>
        </paths>
 20   </logentry>
      <!-- Many more entries ... -->
 22 </log

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 <!DOCTYPE xsl:stylesheet
    [
  4   <!ENTITY dbns "http://docbook.org/ns/docbook">
    ]>
  6 <xsl:stylesheet version="1.0"
      xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  8   
      <xsl:output method="xml" indent="yes"/>
 10   
      <xsl:param name="include.paths" select="1"/>
 12   <xsl:param name="include.copies" select="1"/>
      
 14   <xsl:template match="log">
        <revhistory xmlns="&dbns;">
 16       <xsl:apply-templates/>
        </revhistory>
 18   </xsl:template>
      
 20   <xsl:template match="logentry">
        <revhistory xmlns="&dbns;">
 22       <xsl:apply-templates select="@revision|*"/>
        </revhistory>
 24   </xsl:template>
      
 26   <xsl:template match="logentry/@revision">
        <revnumber xmlns="&dbns;">
 28       <xsl:apply-templates/>
        </revnumber>
 30   </xsl:template>
      
 32   <xsl:template match="tag">
        <revremark xmlns="&dbns;">
 34       <xsl:apply-templates/>
        </revremark>
 36   </xsl:template>
      
 38   <xsl:template match="date">
        <date xmlns="&dbns;">
 40       <xsl:apply-templates/>
        </date>
 42   </xsl:template>
      
 44   <xsl:template match="author">
        <xsl:variable name="firstname" select="substring-before(., ' ')"/>
 46     <xsl:variable name="surname" select="substring-after(., ' ')"/>
        <author xmlns="&dbns;">
 48       <personname>
            <firstname><xsl:value-of select="$firstname"/></firstname>
 50         <!--<othername></othername>-->
            <surname><xsl:value-of select="$surname"/></surname>
 52       </personname>
          <email><xsl:value-of select="@email"/></email>
 54     </author>
      </xsl:template>
 56   
      <xsl:template match="msg">
 58     <revdescription xmlns="&dbns;">
          <para>
 60         <xsl:apply-templates/>
          </para>
 62     </revdescription>
      </xsl:template>
 64   
      <xsl:template match="paths">
 66     <xsl:if test="$include.paths != 0">
          <itemizedlist xmlns="&dbns;">
 68         <title>Paths</title>
            <xsl:apply-templates/>
 70       </itemizedlist>
        </xsl:if>
 72   </xsl:template>
      
 74   <xsl:template match="path">
        <listitem xmlns="&dbns;">
 76       <para>
            <xsl:apply-templates select="@action|text()"/>
 78       </para>
        </listitem>    
 80   </xsl:template>
      
 82   <xsl:template match="path/@action">
        <xsl:text>[</xsl:text>
 84     <xsl:value-of select="."/>
        <xsl:text>] </xsl:text>
 86   </xsl:template>
      <xsl:template match="path/text()">
 88     <filename xmlns="&dbns;">
          <xsl:value-of select="."/>
 90     </filename>
      </xsl:template>
 92 
      <xsl:template match="copyies">
 94     <xsl:if test="$include.paths != 0">
          <listitem xmlns="&dbns;">
 96         <title>Copies</title>
            <para>
 98           <xsl:apply-templates select="@*|text()"/>
            </para>
100       </listitem>
        </xsl:if>
102   </xsl:template>
      <xsl:template match="copy">
104     <listitem xmlns="&dbns;">
          <para>
106         <xsl:apply-templates select="@*|text()"/>
          </para>
108     </listitem>    
      </xsl:template>
110   
      <xsl:template match="copy/@source">
112     <filename xmlns="&dbns;">
          <xsl:value-of select="."/>
114     </filename>
      </xsl:template>
116   <xsl:template match="copy/text()">
        <xsl:text> -> </xsl:text>
118     <filename xmlns="&dbns;">
          <xsl:value-of select="."/>
120     </filename>
      </xsl:template>
122   
    </xsl:stylesheet>