xmlns:xsl="http://www.w3.org/1999/XSL/Transform"

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

    xmlns:exsl="http://exslt.org/common"

    exclude-result-prefixes="doc exsl" version='1.0'>

<xsl:param name="default.table.rules">none</xsl:param>

<xsl:template match="table|informaltable" mode="htmlTable">

  <xsl:param name="tabletype">tabular</xsl:param>

  <xsl:param name="tablewidth">\linewidth-2\tabcolsep</xsl:param>

  <xsl:param name="tableframe">all</xsl:param>

  <xsl:variable name="numcols">

    <xsl:call-template name="widest-html-row">

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="table.width">

    <xsl:call-template name="table.width">

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

    </xsl:call-template>

  </xsl:variable>

  <xsl:variable name="width">

    <xsl:choose>

      <xsl:when test="not(contains($table.width,'auto'))">

        <xsl:value-of select="$table.width"/>

      </xsl:when>

      <xsl:otherwise>

        <xsl:call-template name="table.width">

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

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

        </xsl:call-template>

      </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:variable name="frame">

    <xsl:choose>

      <xsl:when test="@frame">

        <xsl:call-template name="cals.frame">

          <xsl:with-param name="frame" select="@frame"/>

        </xsl:call-template>

      </xsl:when>

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

    </xsl:choose>

  </xsl:variable>

  <xsl:variable name="colspec">

    <xsl:choose>

    <xsl:when test="colgroup or col">

                           mode="make.colspec">

        <xsl:with-param name="colnum" select="1"/>

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

      </xsl:apply-templates>

    </xsl:when>

    <xsl:otherwise>

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

        <xsl:with-param name="colnum" select="1"/>

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

      </xsl:call-template>

    </xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:variable name="rows-head" select="tr[child::th]"/>

  <xsl:variable name="rows-body" select="tr[not(child::th)]"/>

  <xsl:variable name="rows">

    <xsl:choose>

    <xsl:when test="thead">

      <xsl:apply-templates select="thead" mode="htmlTable">

        <xsl:with-param name="colspec" select="exsl:node-set($colspec)"/>

      </xsl:apply-templates>

    </xsl:when>

    <xsl:otherwise>

      <xsl:apply-templates select="$rows-head[1]" mode="htmlTable">

        <xsl:with-param name="colspec" select="exsl:node-set($colspec)"/>

        <xsl:with-param name="rownum" select="1"/>

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

      </xsl:apply-templates>

    </xsl:otherwise>

    </xsl:choose>

    <xsl:choose>

    <xsl:when test="tbody">

      <xsl:apply-templates select="tbody" mode="htmlTable">

        <xsl:with-param name="colspec" select="exsl:node-set($colspec)"/>

      </xsl:apply-templates>

    </xsl:when>

    <xsl:otherwise>

      <xsl:apply-templates select="$rows-body[1]" mode="htmlTable">

        <xsl:with-param name="colspec" select="exsl:node-set($colspec)"/>

                                              count(thead/*) + 1"/>

      </xsl:apply-templates>

    </xsl:otherwise>

    </xsl:choose>

    <xsl:apply-templates select="tfoot/tr[1]" mode="htmlTable">

      <xsl:with-param name="colspec" select="exsl:node-set($colspec)"/>

      <xsl:with-param name="rownum" select="count(.//tr[not(parent::tfoot)])+1"/>

    </xsl:apply-templates>

  </xsl:variable>

  <xsl:variable name="colspec2">

    <xsl:call-template name="build.colwidth">

      <xsl:with-param name="colspec" select="exsl:node-set($colspec)"/>

      <xsl:with-param name="rows" select="exsl:node-set($rows)"/>

    </xsl:call-template>

  </xsl:variable>

  <xsl:copy-of select="exsl:node-set($colspec2)"/>

  <xsl:copy-of select="exsl:node-set($rows)"/>

  -->

  <xsl:variable name="t.rows" select="exsl:node-set($rows)"/>

  <xsl:text>\begingroup%
</xsl:text>

  <xsl:if test="@cellpadding">

    <xsl:text>\setlength{\tabcolsep}{</xsl:text>

    <xsl:choose>

    <xsl:when test="contains(@cellpadding, '%')">

          select="number(substring-before(@cellpadding,'%')) div 100"/>

      <xsl:text>\linewidth</xsl:text>

    </xsl:when>

    <xsl:otherwise>

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

    </xsl:otherwise>

    </xsl:choose>

    <xsl:text>}%
</xsl:text>

  </xsl:if>

  <xsl:text>\setlength{\tablewidth}{</xsl:text>

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

  <xsl:text>}%
</xsl:text>

  <xsl:if test="$tabletype != 'tabularx'">

    <xsl:call-template name="tbl.sizes">

      <xsl:with-param name="colspec" select="exsl:node-set($colspec2)"/>

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

    </xsl:call-template>

  </xsl:if>

  <xsl:if test="$tabletype = 'tabularx'">

    <xsl:call-template name="tbl.valign.x">

      <xsl:with-param name="valign" select="@valign"/>

    </xsl:call-template>

  </xsl:if>

  <xsl:call-template name="tbl.begin">

    <xsl:with-param name="colspec" select="exsl:node-set($colspec2)"/>

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

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

  </xsl:call-template>

  <xsl:if test="$frame = 'all' or $frame = 'top' or $frame = 'topbot'">

    <xsl:text>\hline</xsl:text>

  </xsl:if>

  <xsl:text>
</xsl:text>

  <xsl:variable name="headrows">

                         mode="htmlTable">

      <xsl:with-param name="colspec" select="exsl:node-set($colspec2)"/>

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

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

    </xsl:apply-templates>

  </xsl:variable>

  <xsl:apply-templates select="." mode="newtbl.endhead">

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

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

  </xsl:apply-templates>

                       mode="htmlTable">

    <xsl:with-param name="colspec" select="exsl:node-set($colspec2)"/>

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

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

  </xsl:apply-templates>

  <xsl:if test="$frame = 'all' or $frame = 'bottom' or $frame = 'topbot'">

    <xsl:text>\hline</xsl:text>

  </xsl:if>

  <xsl:text>
</xsl:text>

  <xsl:text>\end{</xsl:text>

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

  <xsl:text>}\endgroup%
</xsl:text>

</xsl:template>

<xsl:template match="row" mode="htmlTable">

  <xsl:param name="colspec"/>

  <xsl:param name="context"/>

  <xsl:param name="frame"/>

  <xsl:apply-templates mode="newtbl">

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

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

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

    <xsl:with-param name="rownum" select="@rownum"/>

  </xsl:apply-templates>

  <xsl:text>\tabularnewline
</xsl:text>

  <xsl:if test="@rowsep=1">

    <xsl:choose>

    <xsl:when test="$newtbl.use.hhline='1'">

      <xsl:call-template name="hhline.build">

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

        <xsl:with-param name="rownum" select="@rownum"/>

      </xsl:call-template>

    </xsl:when>

    <xsl:otherwise>

      <xsl:call-template name="clines.build">

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

        <xsl:with-param name="rownum" select="@rownum"/>

      </xsl:call-template>

    </xsl:otherwise>

    </xsl:choose>

  </xsl:if>

</xsl:template>

<xsl:template match="thead" mode="htmlTable">

  <xsl:param name="colspec"/>

  <xsl:apply-templates select="tr[1]" mode="htmlTable">

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

    <xsl:with-param name="rownum" select="1"/>

  </xsl:apply-templates>

</xsl:template>

<xsl:template match="tbody" mode="htmlTable">

  <xsl:param name="colspec"/>

  <xsl:apply-templates select="tr[1]" mode="htmlTable">

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

                    select="count(preceding-sibling::*[self::tbody or

                                                       self::thead]/*)+1"/>

  </xsl:apply-templates>

</xsl:template>

     has the required 'context'

  -->

<xsl:template match="tr" mode="htmlTable">

  <xsl:param name="rownum"/>

  <xsl:param name="colspec"/>

  <xsl:param name="oldentries"><nop/></xsl:param>

  <xsl:param name="context"/>

  <xsl:variable name="type">

    <xsl:choose>

    <xsl:when test="parent::thead">thead</xsl:when>

    <xsl:when test="parent::tbody">tbody</xsl:when>

    <xsl:when test="parent::tfoot">tfoot</xsl:when>

    <xsl:when test="th">thead</xsl:when>

    <xsl:otherwise>tbody</xsl:otherwise>

    </xsl:choose>

  </xsl:variable>

  <xsl:if test="$context='' or $type=$context">

    <xsl:variable name="entries">

      <xsl:apply-templates select="(td|th)[1]" mode="htmlTable">

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

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

        <xsl:with-param name="colnum" select="1"/>

        <xsl:with-param name="entries" select="exsl:node-set($oldentries)"/>

      </xsl:apply-templates>

    </xsl:variable>

    <row type='{$type}' rownum='{$rownum}'>

      <xsl:call-template name="html.table.row.rules"/>

      <xsl:copy-of select="$entries"/>

    </row>

    <xsl:apply-templates select="following-sibling::tr[1]" mode="htmlTable">

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

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

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

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

    </xsl:apply-templates>

  </xsl:if>

</xsl:template>

<xsl:template name="html.table.row.rules">

                select="(ancestor::table |

                         ancestor::informaltable)[last()]/@border"/>

                select="(ancestor::table |

                         ancestor::informaltable)[last()]/@rules"/>

  <xsl:variable name="rules">

    <xsl:choose>

      <xsl:when test="$table.rules != ''">

        <xsl:value-of select="$table.rules"/>

      </xsl:when>

      <xsl:when test="$border != '' and number($border) != 0">

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

      </xsl:when>

      <xsl:when test="$border != '' and number($border) = 0">

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

      </xsl:when>

      <xsl:when test="$default.table.rules != ''">

        <xsl:value-of select="$default.table.rules"/>

      </xsl:when>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$rules = 'none'">

      <xsl:attribute name="rowsep">0</xsl:attribute>

    </xsl:when>

    <xsl:when test="$rules = 'cols'">

      <xsl:attribute name="rowsep">0</xsl:attribute>

    </xsl:when>

    <xsl:when test="$rules = 'rows' or $rules = 'all'">

      <xsl:variable name="rowborder">

        <xsl:choose>

                          following-sibling::tbody/tr">1</xsl:when>

                          following-sibling::tfoot/tr">1</xsl:when>

                          following-sibling::tr">1</xsl:when>

                          preceding-sibling::tfoot/tr">1</xsl:when>

          <xsl:when test="preceding-sibling::tfoot/tr">1</xsl:when>

             not(@rowspan = count(following-sibling::tr) + 1)">1</xsl:when>

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

        </xsl:choose>

      </xsl:variable>

      <xsl:if test="$rowborder = 1">

        <xsl:attribute name="rowsep">1</xsl:attribute>

      </xsl:if>

    </xsl:when>

                    and not(following-sibling::tr)">

      <xsl:attribute name="rowsep">1</xsl:attribute>

    </xsl:when>

                    and not(preceding-sibling::tr)">

      <xsl:attribute name="rowsep">1</xsl:attribute>

    </xsl:when>

  </xsl:choose>

</xsl:template>

<xsl:template name="html.table.column.rules">

  <xsl:param name="colnum"/>

  <xsl:param name="colmax"/>

                select="(ancestor-or-self::table |

                         ancestor-or-self::informaltable)[last()]/@border"/>

                select="(ancestor-or-self::table |

                         ancestor-or-self::informaltable)[last()]/@rules"/>

  <xsl:variable name="rules">

    <xsl:choose>

      <xsl:when test="$table.rules != ''">

        <xsl:value-of select="$table.rules"/>

      </xsl:when>

      <xsl:when test="$border != '' and number($border) != 0">

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

      </xsl:when>

      <xsl:when test="$border != '' and number($border) = 0">

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

      </xsl:when>

      <xsl:when test="$default.table.rules != ''">

        <xsl:value-of select="$default.table.rules"/>

      </xsl:when>

    </xsl:choose>

  </xsl:variable>

  <xsl:choose>

    <xsl:when test="$rules = 'none'">

      <xsl:attribute name="colsep">0</xsl:attribute>

    </xsl:when>

    <xsl:when test="$rules = 'rows'">

      <xsl:attribute name="colsep">0</xsl:attribute>

    </xsl:when>

    <xsl:when test="$rules = 'groups'">

      <xsl:attribute name="colsep">0</xsl:attribute>

    </xsl:when>

                    ($colnum < $colmax)">

      <xsl:attribute name="colsep">1</xsl:attribute>

    </xsl:when>

  </xsl:choose>

</xsl:template>

<xsl:template match="td|th" mode="htmlTable">

  <xsl:param name="rownum"/>

  <xsl:param name="colnum"/>

  <xsl:param name="colspec"/>

  <xsl:param name="entries"/>

  <xsl:variable name="cols" select="count($colspec/*)"/>

  <xsl:if test="$colnum <= $cols">

                  select="$entries/*[self::entry or self::entrytbl]

                                    [@colstart=$colnum and

                                     @rowend >= $rownum]"/>

    <xsl:choose><xsl:when test="$entry">

      <xsl:copy-of select="$entry"/>

      <xsl:apply-templates mode="htmlTable" select=".">

                        select="$entries/entry[@colstart=$colnum]/@colend + 1"/>

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

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

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

      </xsl:apply-templates>

    </xsl:when><xsl:otherwise>

      <xsl:variable name="colstart" select="$colnum"/>

      <xsl:variable name="colend">

        <xsl:choose>

        <xsl:when test="@colspan">

          <xsl:value-of select="@colspan + $colnum -1"/>

        </xsl:when>

        <xsl:otherwise>

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

        </xsl:otherwise>

        </xsl:choose>

      </xsl:variable>

      <xsl:variable name="rowend">

        <xsl:choose>

        <xsl:when test="@rowspan">

          <xsl:value-of select="@rowspan + $rownum -1"/>

        </xsl:when>

        <xsl:otherwise>

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

        </xsl:otherwise>

        </xsl:choose>

      </xsl:variable>

      <xsl:variable name="rowcolor" select="parent::tr/@bgcolor"/>

      <xsl:variable name="col" select="$colspec/colspec[@colnum=$colstart]"/>

      <xsl:variable name="bgcolor">

        <xsl:choose>

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

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

          </xsl:when>

          <xsl:when test="$col/@bgcolor">

            <xsl:value-of select="$col/@bgcolor"/>

          </xsl:when>

          <xsl:when test="ancestor::*[@bgcolor]">

            <xsl:value-of select="ancestor::*[@bgcolor][last()]/@bgcolor"/>

          </xsl:when>

        </xsl:choose>

      </xsl:variable>

      <xsl:variable name="valign">

        <xsl:choose>

          <xsl:when test="../@valign">

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

          </xsl:when>

          <xsl:when test="$col/@valign">

            <xsl:value-of select="$col/@valign"/>

          </xsl:when>

          <xsl:when test="ancestor::*[@valign]">

            <xsl:value-of select="ancestor::*[@valign][last()]/@valign"/>

          </xsl:when>

        </xsl:choose>

      </xsl:variable>

      <xsl:variable name="align">

        <xsl:choose>

          <xsl:when test="../@align">

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

          </xsl:when>

          <xsl:when test="$col/@align">

            <xsl:value-of select="$col/@align"/>

          </xsl:when>

          <xsl:when test="ancestor::*[@align]">

            <xsl:value-of select="ancestor::*[@align][last()]/@align"/>

          </xsl:when>

        </xsl:choose>

      </xsl:variable>

      <entry>

        <xsl:for-each select="@*"><xsl:copy/></xsl:for-each>

        <xsl:attribute name="colstart">

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

        </xsl:attribute>

        <xsl:attribute name="colend">

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

        </xsl:attribute>

        <xsl:attribute name="rowstart">

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

        </xsl:attribute>

        <xsl:attribute name="rowend">

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

        </xsl:attribute>

        <xsl:if test="$rowend > $rownum">

          <xsl:attribute name="morerows">

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

          </xsl:attribute>

        </xsl:if>

        <xsl:if test="$col/@colsep = 1">

          <xsl:attribute name="colsep">

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

          </xsl:attribute>

        </xsl:if>

        <xsl:if test="not(@bgcolor) and $bgcolor != ''">

          <xsl:attribute name="bgcolor">

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

          </xsl:attribute>

        </xsl:if>

        <xsl:if test="not(@valign) and $valign != ''">

          <xsl:attribute name="valign">

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

          </xsl:attribute>

        </xsl:if>

        <xsl:if test="not(@align) and $align != ''">

          <xsl:attribute name="align">

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

          </xsl:attribute>

        </xsl:if>

        <xsl:element name="output">

          <xsl:apply-templates select="." mode="output"/>

        </xsl:element>

      </entry>

      <xsl:choose>

      <xsl:when test="following-sibling::*[self::td or self::th]">

              select="following-sibling::*[self::td or self::th][1]"

              mode="htmlTable">

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

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

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

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

        </xsl:apply-templates>

      </xsl:when>

      <xsl:when test="$colend < $cols">

        <xsl:call-template name="tbl.blankentry">

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

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

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

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

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

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

        </xsl:call-template>

      </xsl:when>

      </xsl:choose>

    </xsl:otherwise></xsl:choose>

  </xsl:if>

</xsl:template>

<xsl:template match="td|th" mode="output">

  <xsl:call-template name="normalize-border">

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

      <xsl:apply-templates/>

    </xsl:with-param>

  </xsl:call-template>

</xsl:template>

<xsl:template match="tr" mode="span">

  <xsl:param name="currow"/>

  <xsl:variable name="tr.pos" select="position()"/>

                                                    $currow]"/>

  <xsl:if test="$spantds">

      <xsl:attribute name="value">

        select="sum($spantds/@colspan)+count($spantds[not(@colspan)])"/>

      </xsl:attribute>

  </xsl:if>

</xsl:template>

<xsl:template name="widest-html-row">

  <xsl:param name="rows" select="''"/>

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

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

  <xsl:variable name="row" select="$rows[position()=$currow]"/>

  <xsl:choose>

    <xsl:when test="not($row)">

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

    </xsl:when>

    <xsl:otherwise>

      <xsl:variable name="count1" select="count($row/*[not(@colspan)])"/>

      <xsl:variable name="count2" select="sum($row/*/@colspan)"/>

      <xsl:variable name="countn" select="$count1 + $count2"/>

           that span over the current row -->

      <xsl:variable name="spantds">

             select="$rows[position() < $currow]"

             mode="span">

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

        </xsl:apply-templates>

      </xsl:variable>

                    select="sum(exsl:node-set($spantds)/*/@value)"/>

      <foo> <xsl:copy-of select="$spantds"/> </foo>

      <xsl:message>

        <xsl:text>p=</xsl:text><xsl:value-of select="$currow"/>

        <xsl:text> c=</xsl:text><xsl:value-of select="$count"/>

        <xsl:text> s=</xsl:text><xsl:value-of select="$addcols"/>

      </xsl:message>

      -->

      <xsl:choose>

        <xsl:when test="$count > ($countn + $addcols)">

          <xsl:call-template name="widest-html-row">

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

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

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

          </xsl:call-template>

        </xsl:when>

        <xsl:otherwise>

          <xsl:call-template name="widest-html-row">

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

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

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

          </xsl:call-template>

        </xsl:otherwise>

      </xsl:choose>

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="build.colwidth">

  <xsl:param name="colspec"/>

  <xsl:param name="rows"/>

  <xsl:for-each select="$colspec/*">

    <xsl:variable name="pos" select="position()"/>

                  select="$rows/row/entry[@colstart <= $pos and

                                          @colend >= $pos][@width]"/>

    <xsl:variable name="pct">

      <xsl:call-template name="max.percent">

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

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

          <xsl:choose>

          <xsl:when test="substring(@width,string-length(@width))='%'">

            <xsl:value-of select="number(substring-before(@width, '%'))"/>

          </xsl:when>

          <xsl:otherwise>

            <xsl:value-of select="0"/>

          </xsl:otherwise>

          </xsl:choose>

        </xsl:with-param>

      </xsl:call-template>

    </xsl:variable>

    <xsl:variable name="fixed">

      <xsl:call-template name="max.value">

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

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

          <xsl:choose>

          <xsl:when test="string(number(@width))!='NaN'">

            <xsl:value-of select="number(@width)"/>

          </xsl:when>

          <xsl:otherwise>

            <xsl:value-of select="0"/>

          </xsl:otherwise>

          </xsl:choose>

        </xsl:with-param>

      </xsl:call-template>

    </xsl:variable>

    <xsl:variable name="star">

      <xsl:choose>

      <xsl:when test="substring(@width,string-length(@width))='*'">

        <xsl:value-of select="number(substring-before(@width, '*'))"/>

      </xsl:when>

      <xsl:otherwise>

             signify a missing star -->

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

      </xsl:otherwise>

      </xsl:choose>

    </xsl:variable>

    <xsl:message>

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

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

      <xsl:value-of select="count($colentries)"/>

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

      <xsl:text> val=</xsl:text><xsl:value-of select="$fixed"/>

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

    </xsl:message>

    -->

    <xsl:copy>

      <xsl:for-each select="@*"><xsl:copy/></xsl:for-each>

      <xsl:choose>

      <xsl:when test="$star = 0">

        <xsl:attribute name="autowidth">1</xsl:attribute>

        <xsl:attribute name="colwidth">

          <xsl:text>\newtblstarfactor</xsl:text>

        </xsl:attribute>

        <xsl:attribute name="star">

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

        </xsl:attribute>

      </xsl:when>

      <xsl:when test="$star > 0">

        <xsl:attribute name="colwidth">

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

          <xsl:text>\newtblstarfactor</xsl:text>

        </xsl:attribute>

        <xsl:attribute name="star">

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

        </xsl:attribute>

      </xsl:when>

      <xsl:when test="$pct > 0">

        <xsl:variable name="width">

          <xsl:value-of select="$pct div 100"/>

          <xsl:text>\tablewidth</xsl:text>

        </xsl:variable>

        <xsl:attribute name="fixedwidth">

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

        </xsl:attribute>

        <xsl:attribute name="colwidth">

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

        </xsl:attribute>

      </xsl:when>

      <xsl:when test="$fixed > 0">

        <xsl:variable name="width">

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

          <xsl:text>pt</xsl:text>

        </xsl:variable>

        <xsl:attribute name="fixedwidth">

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

        </xsl:attribute>

        <xsl:attribute name="colwidth">

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

        </xsl:attribute>

      </xsl:when>

      <xsl:otherwise>

        <xsl:if test="@width != ''">

          <xsl:message>

            <xsl:text>Warning: Unrecognized width attribute (</xsl:text>

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

            <xsl:text>) in column of HTML table</xsl:text>

          </xsl:message>

        </xsl:if>

        <xsl:attribute name="colwidth">

          <xsl:text>\newtblstarfactor</xsl:text>

        </xsl:attribute>

        <xsl:attribute name="star">1</xsl:attribute>

      </xsl:otherwise>

      </xsl:choose>

    </xsl:copy>

  </xsl:for-each>

</xsl:template>

<xsl:template name="max.percent">

  <xsl:param name="entries"/>

  <xsl:param name="maxpct" select="0"/>

  <xsl:choose>

  <xsl:when test="$entries">

    <xsl:variable name="width" select="$entries[1]/@width"/>

    <xsl:variable name="newpct">

      <xsl:choose>

      <xsl:when test="substring($width,string-length($width))='%'">

                      select="number(substring-before($width, '%'))"/>

        <xsl:choose>

        <xsl:when test="$pct > $maxpct">

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

        </xsl:when>

        <xsl:otherwise>

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

        </xsl:otherwise>

        </xsl:choose>

      </xsl:when>

      <xsl:otherwise>

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

      </xsl:otherwise>

      </xsl:choose>

    </xsl:variable>

    <xsl:call-template name="max.percent">

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

      <xsl:with-param name="entries" select="$entries[position() > 1]"/>

    </xsl:call-template>

  </xsl:when>

  <xsl:otherwise>

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

  </xsl:otherwise>

  </xsl:choose>

</xsl:template>