boost/docca
2
0
Fork 0
mirror of https://github.com/boostorg/docca.git synced 2026-01-19 04:12:08 +00:00
Code Issues Projects Releases Wiki Activity

Update docca XSL to version 2

Browse Source
This commit is contained in:
Vinnie Falco
2019-09-21 09:34:03 -07:00
parent 9bbf76d88b
commit 457bd23cf7
11 changed files with 1527 additions and 1998 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/docca/assemble-quickbook.xsl Normal file
View File

@@ -0,0 +1,20 @@
<!-- Concatenate all the text files from a directory into one big file -->
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
exclude-result-prefixes="xs">
<xsl:output method="text"/>
<!-- TODO: remove this coupling; should be configured in the build file somehow
(add support for Saxon parameter-passing in the build?) -->
<xsl:param name="input-dir" select="'stage2/results'"/>
<xsl:template match="page">
<xsl:copy-of select="unparsed-text(concat($input-dir, '/', @href))"/>
<xsl:apply-templates select="page"/>
<!-- Two line breaks before to ensure it doesn't get absorbed into a preceding list -->
<xsl:text>&#xA;&#xA;[endsect]&#xA;</xsl:text>
</xsl:template>
</xsl:stylesheet>

427
include/docca/base-extract-xml-pages.xsl Normal file
View File

@@ -0,0 +1,427 @@
<xsl:stylesheet version="3.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:d="http://github.com/vinniefalco/docca"
exclude-result-prefixes="xs d"
expand-text="yes">
<!-- TODO: make sure this doesn't screw up any formatting -->
<!-- NEW TODO: verify we don't need/want this -->
<!--
<xsl:output indent="yes"/>
-->
<xsl:include href="common.xsl"/>
<xsl:key name="visible-memberdefs-by-id"
match="memberdef[$include-private-members or not(@prot eq 'private')]"
use="@id"/>
<xsl:key name="elements-by-refid" match="compound | member" use="@refid"/>
<xsl:variable name="index-xml" select="/"/>
<xsl:template match="/">
<index>
<xsl:apply-templates select="/doxygenindex/compound"/>
</index>
<!-- Testing the ID-related functions
<xsl:value-of select="replace(d:extract-ns('put'), '::$', '')"/>
<xsl:text>&#xA;</xsl:text>
<xsl:value-of select="replace(d:extract-ns('foobar::parser::put'), '::$', '')"/>
<xsl:text>&#xA;</xsl:text>
<xsl:value-of select="d:extract-ns('foobar::parser::put&lt;foo::bar, bat::bang>')"/>
<xsl:text>&#xA;</xsl:text>
<xsl:value-of select="d:strip-ns('boost::beast::http::parser::basic_parser&lt; foo::isRequest, bar::parser &gt;')"/>
<xsl:text>&#xA;</xsl:text>
<xsl:value-of select="d:strip-doc-ns('boost::beast::http::parser::basic_parser&lt; foo::isRequest, bar::parser &gt;')"/>
<xsl:text>&#xA;</xsl:text>
<xsl:text>&#xA;</xsl:text>
<xsl:value-of select="d:make-id('boost::beast::http::parser::basic_parser&lt; foo::isRequest, bar::parser &gt;')"/>
-->
</xsl:template>
<!-- Default implementation; can be customized/overridden -->
<xsl:function name="d:should-ignore-compound">
<xsl:param name="compound" as="element(compound)"/>
<xsl:sequence select="false()"/>
</xsl:function>
<xsl:template match="compound[d:should-ignore-compound(.)]"/>
<xsl:template match="compound">
<!-- Load each input file only once -->
<xsl:variable name="source-doc" select="d:get-source-doc(.)"/>
<!-- Ignore private classes unless private members are enabled -->
<xsl:if test="$include-private-members or not($source-doc/doxygen/compounddef/@prot eq 'private')">
<!-- Look up memberdefs (and constrain by visibility) only once -->
<xsl:variable name="memberdefs" select="key('visible-memberdefs-by-id', member/@refid, $source-doc)"/>
<!-- Create a filtered copy of members within their minimal context, listing only the visible ones -->
<xsl:variable name="visible-members" as="element(member)*">
<xsl:variable name="compound" as="element()">
<compound kind="{@kind}" refid="{@refid}">
<name>{name}</name>
<xsl:copy-of select="member[@refid = $memberdefs/@id]"/>
</compound>
</xsl:variable>
<xsl:sequence select="$compound/member"/>
</xsl:variable>
<xsl:apply-templates mode="create-page" select=".">
<xsl:with-param name="source-doc" select="$source-doc" tunnel="yes"/>
<xsl:with-param name="memberdefs" select="$memberdefs" tunnel="yes"/>
<xsl:with-param name="visible-members" select="$visible-members" tunnel="yes"/>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:function name="d:get-source-doc" as="document-node()">
<xsl:param name="compound" as="element(compound)"/>
<xsl:sequence select="document($compound/@refid||'.xml', $index-xml)"/>
</xsl:function>
<!-- Split up the content into class, struct, and member pages -->
<xsl:template mode="create-page" match="*"/>
<xsl:template mode="create-page" match="compound[@kind = 'namespace']">
<xsl:apply-templates mode="child-pages" select="."/>
</xsl:template>
<xsl:template mode="create-page" match="compound[@kind = ('class','struct')]
| compound/member">
<xsl:variable name="page-id" as="xs:string">
<xsl:apply-templates mode="page-id" select="."/>
</xsl:variable>
<page id="{$page-id}" href="{$page-id}.xml">
<xsl:result-document href="xml-pages/{$page-id}.xml">
<xsl:apply-templates mode="page-content" select=".">
<xsl:with-param name="page-id" select="$page-id" tunnel="yes"/>
</xsl:apply-templates>
</xsl:result-document>
<xsl:apply-templates mode="child-pages" select="."/>
</page>
</xsl:template>
<!-- Create the member page for each child (or, if overloaded, the overload-list page) -->
<xsl:template mode="child-pages" match="compound">
<xsl:param name="visible-members" tunnel="yes"/>
<!-- Create a page for each unique member name -->
<xsl:for-each select="$visible-members[not(name = preceding-sibling::member/name)]">
<xsl:apply-templates mode="create-page" select=".">
<xsl:with-param name="is-overload-list-page" select="d:is-overloaded(.)" tunnel="yes"/>
</xsl:apply-templates>
</xsl:for-each>
</xsl:template>
<!-- A member page doesn't have children, unless it is an overload-list page -->
<xsl:template mode="child-pages" match="compound/member">
<xsl:param name="is-overload-list-page" tunnel="yes"/>
<xsl:if test="$is-overload-list-page">
<xsl:apply-templates mode="create-page" select="d:overloaded-members(.)">
<xsl:with-param name="is-overload-list-page" select="false()" tunnel="yes"/>
</xsl:apply-templates>
</xsl:if>
</xsl:template>
<xsl:template mode="page-id" match="compound">{d:make-id(name)}</xsl:template>
<xsl:template mode="page-id" match="member">
<xsl:param name="is-overload-list-page" tunnel="yes"/>
<xsl:value-of>
<xsl:apply-templates mode="base-member-page-id" select="."/>
<!-- Append the overload-specific suffix, if applicable -->
<xsl:if test="d:is-overloaded(.) and not($is-overload-list-page)">
<xsl:value-of select="d:make-id('.overload'||d:overload-position(.))"/>
</xsl:if>
</xsl:value-of>
</xsl:template>
<xsl:function name="d:is-overloaded" as="xs:boolean">
<xsl:param name="member" as="element(member)"/>
<xsl:sequence select="exists(d:overloaded-members($member)[2])"/>
</xsl:function>
<xsl:function name="d:overload-position" as="xs:integer">
<xsl:param name="member" as="element(member)"/>
<xsl:sequence select="1 + count($member/preceding-sibling::member[name eq $member/name])"/>
</xsl:function>
<xsl:function name="d:overloaded-members" as="element(member)+">
<xsl:param name="member" as="element(member)"/>
<xsl:sequence select="$member/../member[name eq $member/name]"/>
</xsl:function>
<xsl:template mode="base-member-page-id" priority="1"
match="compound[@kind eq 'namespace']
/member">{d:make-id(../name||'::'||name)}</xsl:template>
<xsl:template mode="base-member-page-id" match="compound/member">{d:make-id(../name||'.' ||name)}</xsl:template>
<!-- The content for a class or struct is the original source document, pared down some -->
<xsl:template mode="page-content" match="compound">
<xsl:param name="source-doc" tunnel="yes"/>
<xsl:apply-templates mode="compound-page" select="$source-doc"/>
</xsl:template>
<!-- By default, copy everything -->
<xsl:template mode="compound-page" match="@* | node()" name="copy-in-compound-page">
<xsl:copy>
<xsl:apply-templates mode="#current" select="@*"/>
<xsl:apply-templates mode="compound-page-insert" select="."/>
<xsl:apply-templates mode="#current"/>
</xsl:copy>
</xsl:template>
<!-- By default, don't insert anything -->
<xsl:template mode="compound-page-insert" match="*"/>
<xsl:template mode="compound-page" match="listofallmembers"/>
<xsl:template mode="compound-page" match="memberdef/@*"/>
<!-- But directly inside <memberdef>, don't copy anything... -->
<xsl:template mode="compound-page" match="memberdef/node()"/>
<!-- ...except for <name>, <briefdescription>, and <type> -->
<xsl:template mode="compound-page" match="memberdef/name
| memberdef/briefdescription
| memberdef/type" priority="1">
<xsl:call-template name="copy-in-compound-page"/>
</xsl:template>
<!-- Insert a reference to each child member's page ID -->
<xsl:template mode="compound-page-insert" match="memberdef">
<xsl:attribute name="d:page-refid" select="d:make-id(/doxygen/compounddef/compoundname||'.'||name)"/>
</xsl:template>
<!-- Alternative implementation in case we need to start controlling whitespace more
<xsl:template mode="compound-page" match="memberdef">
<memberdef>
<xsl:text>&#xA;</xsl:text>
<xsl:copy-of select="name"/>
<xsl:text>&#xA;</xsl:text>
<xsl:copy-of select="briefdescription"/>
</memberdef>
</xsl:template>
-->
<!-- The content for a member page is a subset of the source document -->
<xsl:template mode="page-content" match="compound/member">
<xsl:param name="is-overload-list-page" tunnel="yes"/>
<xsl:choose>
<xsl:when test="$is-overload-list-page">
<!-- For the overload list page, include the content for every like-named member -->
<xsl:apply-templates mode="list-page" select=".">
<xsl:with-param name="applicable-members" select="d:overloaded-members(.)" tunnel="yes"/>
</xsl:apply-templates>
</xsl:when>
<xsl:otherwise>
<!-- Otherwise, this page is just for one implementation (whether overloaded or not) -->
<xsl:apply-templates mode="member-page" select="."/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<xsl:template mode="list-page member-page" match="member" priority="2">
<xsl:param name="applicable-members" as="element(member)+" select="." tunnel="yes"/>
<xsl:param name="source-doc" tunnel="yes"/>
<xsl:param name="memberdefs" tunnel="yes"/>
<xsl:apply-templates mode="#current" select="$source-doc">
<xsl:with-param name="target-memberdefs"
select="$memberdefs[@id = $applicable-members/@refid]"
tunnel="yes"/>
<xsl:with-param name="member" select="." tunnel="yes"/>
</xsl:apply-templates>
</xsl:template>
<!-- Always copy the name of the parent compound -->
<xsl:template mode="list-page member-page" match="compoundname" priority="2">
<xsl:copy-of select="."/>
</xsl:template>
<!-- Otherwise, only copy an element if it's the target member or one of its ancestors -->
<xsl:template mode="list-page member-page" match="*" priority="1">
<xsl:param name="target-memberdefs" tunnel="yes"/>
<xsl:if test=". intersect $target-memberdefs/ancestor-or-self::*">
<xsl:next-match/>
</xsl:if>
</xsl:template>
<!-- By default, copy everything -->
<xsl:template mode="list-page" match="@* | node()">
<xsl:copy>
<xsl:apply-templates mode="#current" select="@*"/>
<xsl:apply-templates mode="list-page-insert" select="."/>
<xsl:apply-templates mode="#current"/>
</xsl:copy>
</xsl:template>
<!-- By default, don't insert anything -->
<xsl:template mode="list-page-insert" match="*"/>
<!-- By default, copy everything -->
<xsl:template mode="member-page
copy-member-content" match="@* | node()">
<xsl:copy>
<xsl:apply-templates mode="#current" select="@*"/>
<xsl:apply-templates mode="member-page-insert" select="."/>
<xsl:apply-templates mode="#current"/>
<xsl:apply-templates mode="member-page-append" select="."/>
</xsl:copy>
</xsl:template>
<!-- By default, don't insert or append anything -->
<xsl:template mode="member-page-insert
member-page-append" match="*"/>
<!-- Strip out extraneous whitespace -->
<xsl:template mode="list-page member-page" match="compounddef/text() | sectiondef/text()"/>
<!-- Switch to an unfiltered copy once we're done filtering out the undesired elements -->
<xsl:template mode="list-page member-page" match="memberdef/node()" priority="2">
<xsl:apply-templates mode="copy-member-content" select="."/>
</xsl:template>
<!-- Add the page ID to the top of all page types -->
<xsl:template mode="compound-page-insert
member-page-insert
list-page-insert" match="/doxygen" priority="2">
<xsl:param name="page-id" tunnel="yes"/>
<xsl:attribute name="d:page-id" select="$page-id"/>
<xsl:next-match/>
</xsl:template>
<!-- Also, if applicable, insert the overload position and/or base compound reference of this member -->
<xsl:template mode="member-page-insert" match="/doxygen" priority="1">
<xsl:param name="member" tunnel="yes"/>
<xsl:if test="d:is-overloaded($member)">
<xsl:attribute name="d:overload-position" select="d:overload-position($member)"/>
<xsl:attribute name="d:overload-size" select="count(d:overloaded-members($member))"/>
</xsl:if>
<xsl:if test="$member[not(starts-with(@refid, ../@refid))]">
<xsl:variable name="base-compound" select="$index-xml/*/compound[starts-with($member/@refid, @refid)]
[not(d:should-ignore-compound(.))]"/>
<xsl:apply-templates mode="base-compound-atts" select="$base-compound"/>
</xsl:if>
<xsl:next-match/>
</xsl:template>
<xsl:template mode="base-compound-atts" match="compound">
<xsl:attribute name="d:base-compound-name" select="d:strip-doc-ns(name)"/>
<xsl:attribute name="d:base-compound-refid">
<xsl:apply-templates mode="page-id" select="."/>
</xsl:attribute>
</xsl:template>
<!-- Make data available for the typedef tables, if applicable -->
<xsl:template mode="member-page-append" match="memberdef[@kind eq 'typedef']
[type/ref]
[not(contains(type, '*'))]">
<xsl:for-each select="type/ref">
<d:referenced-typedef-class>
<xsl:variable name="compound" select="d:get-target-element(.)[self::compound]"/>
<xsl:apply-templates mode="compound-page" select="$compound ! d:get-source-doc(.)/*/compounddef"/>
</d:referenced-typedef-class>
</xsl:for-each>
</xsl:template>
<!-- Finally, add the page type -->
<xsl:template mode="compound-page-insert" match="/doxygen">
<xsl:attribute name="d:page-type" select="'compound'"/>
</xsl:template>
<xsl:template mode="member-page-insert" match="/doxygen">
<xsl:attribute name="d:page-type" select="'member'"/>
</xsl:template>
<xsl:template mode="list-page-insert" match="/doxygen">
<xsl:attribute name="d:page-type" select="'overload-list'"/>
</xsl:template>
<!-- For overload-list pages, include the page id for each member -->
<xsl:template mode="list-page-insert" match="memberdef">
<xsl:param name="applicable-members" tunnel="yes"/>
<xsl:variable name="this-id" select="@id"/>
<xsl:variable name="original-member" select="$applicable-members[@refid eq $this-id]"/>
<xsl:attribute name="d:page-refid">
<xsl:apply-templates mode="page-id" select="$original-member">
<xsl:with-param name="is-overload-list-page" select="false()" tunnel="yes"/>
</xsl:apply-templates>
</xsl:attribute>
</xsl:template>
<!-- For public innerclasses, insert the referenced class inline -->
<xsl:template mode="compound-page-insert" match="innerclass[@prot eq 'public']">
<xsl:attribute name="d:page-refid" select="d:make-id(.)"/>
<d:referenced-inner-class>
<xsl:variable name="compound" select="d:get-target-element(.)" as="element(compound)"/>
<xsl:apply-templates mode="compound-page" select="d:get-source-doc($compound)/*/compounddef"/>
</d:referenced-inner-class>
</xsl:template>
<!-- TODO: refactor this rule -->
<!-- Resolve the referenced page IDs for later link generation -->
<xsl:template mode="compound-page-insert member-page-insert" match="ref" name="insert-referenced-page-id">
<xsl:attribute name="d:refid">
<xsl:apply-templates mode="page-id" select="d:get-target-element(.)"/>
</xsl:attribute>
</xsl:template>
<xsl:function name="d:get-target-element" as="element()?"> <!-- to allow for partial builds -->
<!--
<xsl:function name="d:get-target-element" as="element()">
-->
<xsl:param name="ref" as="element()"/> <!-- <ref> or <innerclass> or... -->
<xsl:variable name="referenced-elements" select="key('elements-by-refid', $ref/@refid, $index-xml)"/>
<xsl:variable name="result" as="element()?">
<xsl:choose>
<!-- Handle the case where the referenced element appears two or more times in index.xml -->
<!-- If there's no ambiguity, we're done! -->
<xsl:when test="count($referenced-elements) eq 1">
<xsl:apply-templates mode="find-target-element" select="$referenced-elements"/>
</xsl:when>
<xsl:otherwise>
<!-- Otherwise, see if a namespace in the link text successfully disambiguates -->
<xsl:variable name="qualified-reference" as="element()*">
<xsl:variable name="parent-in-link-text"
select="if (contains($ref,'::'))
then d:extract-ns-without-suffix($ref)
else ''"/>
<xsl:sequence select="$referenced-elements[ends-with(parent::compound/name, '::'||$parent-in-link-text)]"/>
</xsl:variable>
<xsl:choose>
<xsl:when test="count($qualified-reference) eq 1">
<xsl:apply-templates mode="find-target-element" select="$qualified-reference"/>
</xsl:when>
<xsl:otherwise>
<!-- Otherwise, favor the member that's in the same class or namespace as the current page -->
<xsl:variable name="sibling-reference" as="element()*">
<xsl:variable name="compound-for-current-page" select="root($ref)/doxygen/compounddef/compoundname/string()"/>
<xsl:sequence select="$referenced-elements[parent::compound/name eq $compound-for-current-page]"/>
</xsl:variable>
<xsl:choose>
<xsl:when test="count($sibling-reference) eq 1">
<xsl:apply-templates mode="find-target-element" select="$sibling-reference"/>
</xsl:when>
<!-- If all else fails, give up and just use the first one -->
<xsl:otherwise>
<xsl:apply-templates mode="find-target-element" select="$referenced-elements[1]"/>
</xsl:otherwise>
</xsl:choose>
</xsl:otherwise>
</xsl:choose>
</xsl:otherwise>
</xsl:choose>
</xsl:variable>
<xsl:if test="not($result)">
<xsl:message>Unable to find referenced ID: <xsl:value-of select="$ref/@refid"/></xsl:message>
</xsl:if>
<xsl:sequence select="$result"/>
</xsl:function>
<xsl:template mode="find-target-element" match="compound | member">
<xsl:sequence select="."/>
</xsl:template>
<!-- In the index XML, enumvalue "members" immediately follow the corresponding enum member -->
<xsl:template mode="find-target-element" match="member[@kind eq 'enumvalue']">
<xsl:sequence select="preceding-sibling::member[@kind eq 'enum'][1]"/>
</xsl:template>
</xsl:stylesheet>

590
include/docca/base-stage1.xsl Normal file
View File

@@ -0,0 +1,590 @@
<!DOCTYPE xsl:stylesheet [
<!-- TODO: complete this list -->
<!ENTITY BLOCK_LEVEL_ELEMENT "programlisting
| itemizedlist
| orderedlist
| parameterlist
| simplesect
| para
| table
| linebreak">
]>
<xsl:stylesheet version="3.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:d="http://github.com/vinniefalco/docca"
exclude-result-prefixes="xs d"
expand-text="yes">
<xsl:include href="common.xsl"/>
<xsl:output indent="yes"/>
<xsl:template match="/doxygen" priority="1">
<page id="{@d:page-id}" type="{@d:page-type}">
<xsl:apply-templates mode="index-term-atts" select="."/>
<title>
<xsl:apply-templates mode="page-title" select="."/>
</title>
<xsl:apply-templates select="@d:base-compound-refid"/>
<xsl:next-match/>
</page>
</xsl:template>
<xsl:template match="@d:base-compound-refid">
<div>(Inherited from <ref d:refid="{.}">{../@d:base-compound-name}</ref>)</div>
</xsl:template>
<!-- Put an index term on every page except class (compound) and overloaded-member pages -->
<xsl:template mode="index-term-atts" match="doxygen[@d:page-type eq 'compound' or @d:overload-position]"/>
<xsl:template mode="index-term-atts" match="doxygen">
<xsl:attribute name="primary-index-term">
<xsl:apply-templates mode="primary-index-term" select="."/>
</xsl:attribute>
<xsl:apply-templates mode="secondary-index-term-att" select="."/>
</xsl:template>
<!-- By default, use the member name as the primary term... -->
<xsl:template mode="primary-index-term" match="doxygen">
<xsl:apply-templates mode="member-name" select="."/>
</xsl:template>
<!-- ...and the compound name as the secondary term. -->
<xsl:template mode="secondary-index-term-att" match="doxygen">
<xsl:attribute name="secondary-index-term">
<xsl:apply-templates mode="compound-name" select="."/>
</xsl:attribute>
</xsl:template>
<!-- But with namespace members, use the fully-qualified name as the primary term... -->
<xsl:template mode="primary-index-term" match="doxygen[compounddef/@kind eq 'namespace']">
<xsl:apply-templates mode="compound-and-member-name" select="."/>
</xsl:template>
<!-- ...and no secondary term. -->
<xsl:template mode="secondary-index-term-att" match="doxygen[compounddef/@kind eq 'namespace']"/>
<xsl:template mode="compound-name" match="doxygen"
>{d:strip-doc-ns(compounddef/compoundname)}</xsl:template>
<xsl:template mode="member-name" match="doxygen"
>{(compounddef/sectiondef/memberdef/name)[1]}</xsl:template>
<xsl:template mode="compound-and-member-name" match="doxygen">
<xsl:variable name="compound-name" as="xs:string">
<xsl:apply-templates mode="compound-name" select="."/>
</xsl:variable>
<xsl:if test="$compound-name">{$compound-name}::</xsl:if>
<xsl:apply-templates mode="member-name" select="."/>
</xsl:template>
<xsl:template mode="page-title" match="doxygen[@d:page-type eq 'compound']">
<xsl:apply-templates mode="compound-name" select="."/>
</xsl:template>
<xsl:template mode="page-title" match="doxygen">
<xsl:apply-templates mode="compound-and-member-name" select="."/>
<xsl:apply-templates mode="overload-qualifier" select="."/>
</xsl:template>
<xsl:template mode="overload-qualifier" match="doxygen"/>
<xsl:template mode="overload-qualifier" match="doxygen[@d:overload-position]">
<xsl:text> (</xsl:text>
<xsl:value-of select="@d:overload-position"/>
<xsl:text> of </xsl:text>
<xsl:value-of select="@d:overload-size"/>
<xsl:text> overloads)</xsl:text>
</xsl:template>
<xsl:template match="/doxygen[@d:page-type eq 'compound']">
<xsl:apply-templates select="compounddef"/>
</xsl:template>
<xsl:template match="/doxygen[@d:page-type eq 'member']">
<xsl:apply-templates select="compounddef/sectiondef/memberdef"/> <!-- should just be one -->
</xsl:template>
<xsl:template match="/doxygen[@d:page-type eq 'overload-list']">
<xsl:apply-templates select="(compounddef/sectiondef/memberdef)[1]"/>
</xsl:template>
<xsl:template match="compounddef | memberdef" priority="2">
<xsl:next-match/>
<xsl:apply-templates mode="includes" select=".">
<xsl:with-param name="is-footer" select="true()"/>
</xsl:apply-templates>
</xsl:template>
<!-- For convenience, pre-calculate some member sequences and tunnel them through -->
<xsl:template match="compounddef" priority="1">
<xsl:next-match>
<xsl:with-param name="public-types"
select="sectiondef[@kind eq 'public-type']/memberdef
| innerclass[@prot eq 'public'][not(d:should-ignore-inner-class(.))]"
tunnel="yes"/>
<xsl:with-param name="friends"
select="sectiondef[@kind eq 'friend']/memberdef[not(type eq 'friend class')]
[not(d:should-ignore-friend(.))]"
tunnel="yes"/>
</xsl:next-match>
</xsl:template>
<xsl:template match="compounddef">
<xsl:param name="public-types" tunnel="yes"/>
<xsl:param name="friends" tunnel="yes"/>
<xsl:apply-templates select="briefdescription"/>
<xsl:apply-templates mode="section"
select=".,
( $public-types/self::memberdef/..
| $public-types/self::innerclass
)[1],
sectiondef[@kind = ( 'public-func', 'public-static-func')],
sectiondef[@kind = ('protected-func','protected-static-func')],
sectiondef[@kind = ( 'private-func', 'private-static-func')][$include-private-members],
sectiondef[@kind = ( 'public-attrib', 'public-static-attrib')],
sectiondef[@kind = ('protected-attrib','protected-static-attrib')],
sectiondef[@kind = ( 'private-attrib', 'private-static-attrib')][$include-private-members],
$friends/..,
sectiondef[@kind eq 'related'],
detaileddescription
"/>
</xsl:template>
<xsl:template match="memberdef">
<xsl:apply-templates select="briefdescription"/>
<xsl:apply-templates mode="section" select="., detaileddescription"/>
</xsl:template>
<xsl:template match="memberdef[@kind eq 'enum']">
<xsl:apply-templates select="briefdescription"/>
<xsl:apply-templates mode="section" select="., parent::sectiondef, detaileddescription"/>
</xsl:template>
<xsl:template match="memberdef[/doxygen/@d:page-type eq 'overload-list']">
<xsl:apply-templates mode="overload-list" select="../../sectiondef/memberdef"/>
</xsl:template>
<xsl:template mode="overload-list" match="memberdef">
<xsl:apply-templates select="briefdescription[not(. = ../preceding-sibling::*/briefdescription)]"/>
<overloaded-member>
<xsl:apply-templates mode="normalize-params" select="templateparamlist"/>
<xsl:apply-templates mode="modifier" select="(@explicit, @friend, @static)[. eq 'yes'],
@virt[. eq 'virtual']"/>
<xsl:apply-templates select="type"/>
<ref d:refid="{@d:page-refid}">{name}</ref>
<params>
<xsl:apply-templates select="param"/>
</params>
<xsl:apply-templates mode="modifier" select="@const[. eq 'yes']"/>
</overloaded-member>
</xsl:template>
<xsl:template mode="modifier" match="@*">
<modifier>{local-name(.)}</modifier>
</xsl:template>
<xsl:template mode="modifier" match="@virt">
<modifier>virtual</modifier>
</xsl:template>
<xsl:template match="type">
<type>
<xsl:value-of select="d:cleanup-type(normalize-space(.))"/>
</type>
</xsl:template>
<!-- d:cleanup-param() may not be needed, and the above may suffice. (TODO: confirm this and remove d:cleanup-param() if so)
<xsl:template match="param/type">
<type>
<xsl:value-of select="d:cleanup-param(.)"/>
</type>
</xsl:template>
-->
<!-- TODO: Should this be a custom rule or built-in? -->
<xsl:template mode="section" match="simplesect[matches(title,'Concepts:?')]"/>
<xsl:template mode="section" match="*">
<section>
<heading>
<xsl:apply-templates mode="section-heading" select="."/>
</heading>
<xsl:apply-templates mode="section-body" select="."/>
</section>
</xsl:template>
<xsl:template match="simplesect | parameterlist">
<xsl:apply-templates mode="section" select="."/>
</xsl:template>
<xsl:template mode="section-heading" match="memberdef |
compounddef ">Synopsis</xsl:template>
<xsl:template mode="section-heading" match="detaileddescription">Description</xsl:template>
<xsl:template mode="section-heading" match="simplesect[@kind eq 'note' ]">Remarks</xsl:template>
<xsl:template mode="section-heading" match="simplesect[@kind eq 'see' ]">See Also</xsl:template>
<xsl:template mode="section-heading" match="simplesect[@kind eq 'return']">Return Value</xsl:template>
<xsl:template mode="section-heading" match="simplesect" >{title}</xsl:template>
<xsl:template mode="section-heading" match="parameterlist[@kind eq 'exception' ]">Exceptions</xsl:template>
<xsl:template mode="section-heading" match="parameterlist[@kind eq 'templateparam']">Template Parameters</xsl:template>
<xsl:template mode="section-heading" match="parameterlist ">Parameters</xsl:template>
<xsl:template mode="section-heading" match="innerclass
| sectiondef[@kind eq 'public-type']">Types</xsl:template>
<xsl:template mode="section-heading" match="sectiondef[@kind eq 'friend' ]">Friends</xsl:template>
<xsl:template mode="section-heading" match="sectiondef[@kind eq 'related' ]">Related Functions</xsl:template>
<xsl:template mode="section-heading" match="sectiondef[@kind eq 'enum']">Values</xsl:template>
<xsl:template mode="section-heading" match="sectiondef">
<xsl:apply-templates mode="access-level" select="@kind"/>
<xsl:apply-templates mode="member-kind" select="@kind"/>
</xsl:template>
<xsl:template mode="access-level" match="@kind[starts-with(.,'public' )]"/>
<xsl:template mode="access-level" match="@kind[starts-with(.,'protected')]">Protected </xsl:template>
<xsl:template mode="access-level" match="@kind[starts-with(.,'private' )]">Private </xsl:template>
<xsl:template mode="member-kind" match="@kind[ends-with(.,'func' )]">Member Functions</xsl:template>
<xsl:template mode="member-kind" match="@kind[ends-with(.,'attrib')]">Data Members</xsl:template>
<xsl:template mode="section-body" match="sectiondef | innerclass | parameterlist">
<table>
<tr>
<th>
<xsl:apply-templates mode="column-1-name" select="."/>
</th>
<th>
<xsl:apply-templates mode="column-2-name" select="."/>
</th>
</tr>
<xsl:apply-templates mode="table-body" select="."/>
</table>
</xsl:template>
<xsl:template mode="column-1-name" match="*">Name</xsl:template>
<xsl:template mode="column-2-name" match="*">Description</xsl:template>
<xsl:template mode="column-1-name"
match="parameterlist[@kind = ('exception','templateparam')]">Type</xsl:template>
<xsl:template mode="column-2-name" match="parameterlist[@kind eq 'exception']">Thrown On</xsl:template>
<xsl:template mode="table-body" match="parameterlist">
<xsl:apply-templates mode="parameter-row" select="parameteritem"/>
</xsl:template>
<xsl:template mode="parameter-row" match="parameteritem">
<tr>
<td>
<code>
<!-- ASSUMPTION: <parameternamelist> only ever has one <parametername> child -->
<xsl:apply-templates select="parameternamelist/parametername/node()"/>
</code>
</td>
<td>
<xsl:apply-templates select="parameterdescription/node()"/>
</td>
</tr>
</xsl:template>
<xsl:template mode="table-body" match="sectiondef[@kind eq 'enum']">
<xsl:apply-templates mode="enum-row" select="memberdef/enumvalue"/> <!-- Use input order for enum values -->
</xsl:template>
<xsl:template mode="enum-row" match="enumvalue">
<tr>
<td>
<code>{name}</code>
</td>
<td>
<xsl:apply-templates select="briefdescription, detaileddescription"/>
</td>
</tr>
</xsl:template>
<xsl:template mode="table-body" match="sectiondef | innerclass">
<xsl:variable name="member-nodes" as="element()*">
<xsl:apply-templates mode="member-nodes" select="."/>
</xsl:variable>
<xsl:apply-templates mode="member-row" select="$member-nodes">
<xsl:sort select="d:member-name(.)"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template mode="member-nodes" match="innerclass | sectiondef[@kind eq 'public-type']">
<xsl:param name="public-types" tunnel="yes"/>
<xsl:sequence select="$public-types"/>
</xsl:template>
<xsl:template mode="member-nodes" match="sectiondef[@kind eq 'friend']">
<xsl:param name="friends" tunnel="yes"/>
<xsl:sequence select="$friends"/>
</xsl:template>
<xsl:template mode="member-nodes" match="sectiondef">
<xsl:sequence select="memberdef"/>
</xsl:template>
<xsl:function name="d:member-name">
<xsl:param name="element"/>
<xsl:apply-templates mode="member-name" select="$element"/>
</xsl:function>
<xsl:template mode="member-name" match="memberdef">
<xsl:sequence select="name"/>
</xsl:template>
<xsl:template mode="member-name" match="innerclass">
<xsl:sequence select="d:referenced-inner-class/compounddef/compoundname ! d:strip-ns(.)"/>
</xsl:template>
<!-- Only output a table row for the first instance of each name (ignore overloads) -->
<xsl:template mode="member-row" match="memberdef[name = preceding-sibling::memberdef/name]"/>
<xsl:template mode="member-row" match="*">
<tr>
<td>
<bold>
<ref d:refid="{@d:page-refid}">{d:member-name(.)}</ref>
</bold>
</td>
<td>
<xsl:apply-templates mode="member-description" select="."/>
</td>
</tr>
</xsl:template>
<xsl:template mode="member-description" match="innerclass">
<xsl:apply-templates select="d:referenced-inner-class/compounddef/briefdescription"/>
</xsl:template>
<xsl:template mode="member-description" match="memberdef">
<xsl:variable name="descriptions" select="../memberdef[name eq current()/name]/briefdescription"/>
<!-- Pull in any overload descriptions but only if they vary -->
<xsl:for-each select="distinct-values($descriptions)">
<xsl:apply-templates select="$descriptions[. eq current()][1]"/>
</xsl:for-each>
</xsl:template>
<xsl:template mode="section-body" match="detaileddescription | simplesect">
<xsl:apply-templates/>
</xsl:template>
<xsl:template mode="section-body" match="compounddef | memberdef" priority="1">
<xsl:apply-templates mode="includes" select="."/>
<xsl:next-match/>
</xsl:template>
<xsl:template mode="section-body" match="compounddef">
<compound>
<xsl:apply-templates mode="normalize-params" select="templateparamlist"/>
<kind>{@kind}</kind>
<name>{d:strip-ns(compoundname)}</name>
<xsl:for-each select="basecompoundref[not(d:should-ignore-base(.))]">
<base>
<prot>{@prot}</prot>
<name>{d:strip-doc-ns(.)}</name>
</base>
</xsl:for-each>
</compound>
</xsl:template>
<xsl:template mode="section-body" match="memberdef[@kind eq 'typedef']">
<typedef>
<xsl:apply-templates mode="normalize-params" select="templateparamlist"/>
<xsl:apply-templates select="name, type"/>
</typedef>
<!-- Nested compounddefs were derived from refs in the typedef's type -->
<xsl:apply-templates select="d:referenced-typedef-class/compounddef"/>
</xsl:template>
<!-- Suppress the display of several aspects of referenced typedef classes -->
<!-- Don't show the briefdescription -->
<xsl:template match="d:referenced-typedef-class/compounddef/briefdescription"/>
<!-- Don't show the Synopsis -->
<xsl:template mode="section" match="d:referenced-typedef-class/compounddef"/>
<!-- Exclude the "Description" heading (only show the body) -->
<xsl:template mode="section" match="d:referenced-typedef-class/compounddef/detaileddescription">
<xsl:apply-templates mode="section-body" select="."/>
</xsl:template>
<!-- Don't show the includes header or footer -->
<xsl:template mode="includes" match="d:referenced-typedef-class/compounddef"/>
<xsl:template mode="section-body" match="memberdef[@kind eq 'enum']">
<enum>
<xsl:apply-templates select="name"/>
</enum>
</xsl:template>
<xsl:template mode="section-body" match="memberdef[@kind eq 'variable']">
<variable>
<xsl:apply-templates mode="modifier" select="@static[. eq 'yes']"/>
<xsl:apply-templates select="type, name"/>
<xsl:apply-templates select="initializer[count(../initializer) eq 1]"/>
</variable>
</xsl:template>
<xsl:template mode="section-body" match="memberdef[@kind = ('function','friend')]">
<function>
<xsl:apply-templates mode="normalize-params" select="templateparamlist"/>
<xsl:apply-templates mode="modifier" select="@static[. eq 'yes'],
@virt [. eq 'virtual']"/>
<xsl:apply-templates select="type, name"/>
<params>
<xsl:apply-templates select="param"/>
</params>
<xsl:apply-templates mode="modifier" select="@const[. eq 'yes']"/>
</function>
</xsl:template>
<!-- TODO: make sure this is robust and handles all the possible cases well -->
<xsl:template mode="normalize-params" match="templateparamlist/param/type[not(../declname)]
[starts-with(.,'class ')]"
priority="1">
<type>class</type>
<declname>{substring-after(.,'class ')}</declname>
</xsl:template>
<xsl:template mode="normalize-params" match="templateparamlist/param/type[not(../declname)]">
<ERROR message="param neither has a declname nor a 'class ' prefix in the type"/>
</xsl:template>
<xsl:template mode="normalize-params" match="templateparamlist/param/defname"/>
<!-- We only need to keep the @file attribute -->
<xsl:template match="location/@*[. except ../@file]"/>
<xsl:template match="briefdescription | detaileddescription">
<div>
<xsl:apply-templates/>
</div>
</xsl:template>
<xsl:template match="simplesect/title"/>
<!-- TODO: verify we don't need this; it was causing duplicate headings in simplesect sections
<xsl:template match="title">
<heading>
<xsl:apply-templates/>
</heading>
</xsl:template>
-->
<!-- By default, don't output an includes header or footer -->
<xsl:template mode="includes" match="*"/>
<!-- TODO: Review; this is meant to effect what the previous code did, but I'm not sure it captures the original intentions -->
<xsl:template mode="includes" match="compounddef
| memberdef[@kind eq 'friend' or ../../@kind eq 'namespace']
[not(/doxygen/@d:page-type eq 'overload-list')]">
<xsl:param name="is-footer"/>
<para>
<xsl:choose>
<xsl:when test="$is-footer">
<footer>
<xsl:apply-templates select="location"/>
</footer>
</xsl:when>
<xsl:otherwise>
<xsl:apply-templates select="location"/>
</xsl:otherwise>
</xsl:choose>
</para>
</xsl:template>
<!-- Strip the project namespace prefix from link display names
(matching the text node so this will still work with the strip-leading-space mode/process below) -->
<!-- TODO: figure out if we need anything like this (maybe not).
<xsl:template match="ref/text()[starts-with(.,$doc-ns)]">
<xsl:value-of select="d:strip-doc-ns(.)"/>
</xsl:template>
-->
<!-- When a <para> directly contains a mix of inline nodes and block-level elements, normalize its content -->
<xsl:template match="para[&BLOCK_LEVEL_ELEMENT;]">
<para>
<xsl:for-each-group select="* | text()" group-adjacent="d:is-inline(.)">
<xsl:apply-templates mode="capture-ranges" select="."/>
</xsl:for-each-group>
</para>
</xsl:template>
<xsl:function name="d:is-inline">
<xsl:param name="node"/>
<xsl:sequence select="not($node/../(&BLOCK_LEVEL_ELEMENT;)[. is $node])"/>
</xsl:function>
<!-- Process the block-level elements as usual -->
<xsl:template mode="capture-ranges" match="node()">
<xsl:apply-templates select="current-group()"/>
</xsl:template>
<!-- Wrap contiguous ranges of inline children in a nested <para> -->
<xsl:template mode="capture-ranges" match="node()[d:is-inline(.)]">
<xsl:choose>
<!-- But only if it has text or if the group has more than one node -->
<xsl:when test="normalize-space(.) or current-group()[2]">
<para>
<xsl:apply-templates mode="strip-leading-space" select="."/>
</para>
</xsl:when>
<xsl:otherwise>
<xsl:next-match/>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<!-- Strip leading whitespace from the nested paragraphs to prevent eventual interpretation as a code block -->
<xsl:template mode="strip-leading-space" match="*">
<xsl:copy>
<xsl:apply-templates mode="#current" select="@* | node()[1]"/>
</xsl:copy>
<xsl:apply-templates mode="#current" select="following-sibling::node()[1]
[ancestor-or-self::node() intersect current-group()]"/>
</xsl:template>
<xsl:template mode="strip-leading-space" match="@*">
<xsl:copy/>
</xsl:template>
<xsl:template mode="strip-leading-space" match="text()">
<xsl:param name="done-stripping" tunnel="yes" select="false()"/>
<xsl:choose>
<xsl:when test="$done-stripping">
<xsl:apply-templates select="."/>
</xsl:when>
<xsl:otherwise>
<xsl:sequence select="replace(.,'^\s+','')"/>
</xsl:otherwise>
</xsl:choose>
<xsl:apply-templates mode="#current" select="following-sibling::node()[1]
[ancestor-or-self::node() intersect current-group()]">
<xsl:with-param name="done-stripping" select="$done-stripping or normalize-space(.)" tunnel="yes"/>
</xsl:apply-templates>
</xsl:template>
<xsl:template mode="#default normalize-params" match="@* | node()">
<xsl:copy copy-namespaces="no">
<xsl:apply-templates mode="#current" select="@* | node()"/>
</xsl:copy>
</xsl:template>
</xsl:stylesheet>

109
include/docca/common.xsl Normal file
View File

@@ -0,0 +1,109 @@
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:d="http://github.com/vinniefalco/docca"
exclude-result-prefixes="xs d">
<xsl:variable name="nl" select="'&#xA;'"/>
<xsl:variable name="leading-ns-regex" select="'^([^:&lt;]+::)+'"/>
<xsl:function name="d:extract-ns-without-suffix">
<xsl:param name="name"/>
<xsl:sequence select="replace(d:extract-ns($name), '::$', '')"/>
</xsl:function>
<xsl:function name="d:extract-ns">
<xsl:param name="name"/>
<xsl:sequence select="replace($name, '('||$leading-ns-regex||').*', '$1')"/>
</xsl:function>
<!-- Strip all C++ namespace prefixes that come at the beginning -->
<xsl:function name="d:strip-ns">
<xsl:param name="name"/>
<xsl:sequence select="replace($name, $leading-ns-regex, '')"/>
</xsl:function>
<!-- Strip the common C++ namespace prefix for the docs as a whole -->
<!-- ASSUMPTION: $doc-ns is defined in the customizing stylesheet -->
<xsl:function name="d:strip-doc-ns">
<xsl:param name="name"/>
<xsl:sequence select="if ($name eq $doc-ns)
then ''
else replace($name, '^'||$doc-ns||'::', '')"/>
</xsl:function>
<xsl:function name="d:make-id">
<xsl:param name="name"/>
<xsl:sequence select="d:perform-replacements($name, $id-replacements)"/>
</xsl:function>
<xsl:function name="d:perform-replacements">
<xsl:param name="name"/>
<xsl:param name="replacements"/>
<xsl:variable name="next" select="head($replacements)"/>
<xsl:variable name="rest" select="tail($replacements)"/>
<xsl:sequence select="if (exists($next))
then d:perform-replacements(replace($name, $next/@pattern, $next/@with), $rest)
else $name"/>
</xsl:function>
<xsl:variable name="id-replacements" select="$additional-id-replacements, $base-id-replacements"/>
<!-- Can be overridden by a customizing stylesheet -->
<xsl:variable name="additional-id-replacements" as="element(replace)*" select="()"/>
<xsl:variable name="base-id-replacements" as="element(replace)+">
<replace pattern="^boost::system::" with=""/> <!-- TODO: verify this is generic enough not to be in a custom stylesheet -->
<replace pattern="boost__posix_time__ptime" with="ptime"/> <!-- TODO: verify this is correct; it smells... (the input looks already partially processed) -->
<replace pattern="::" with="__"/>
<replace pattern="=" with="_eq_"/>
<replace pattern="!" with="_not_"/>
<replace pattern="->" with="_arrow_"/>
<replace pattern="&lt;" with="_lt_"/>
<replace pattern=">" with="_gt_"/>
<replace pattern="^~" with="_dtor_"/> <!-- destructor -->
<replace pattern="~" with="_"/>
<replace pattern="\[" with="_lb_"/>
<replace pattern="\]" with="_rb_"/>
<replace pattern="\(" with="_lp_"/>
<replace pattern="\)" with="_rp_"/>
<replace pattern="\+" with="_plus_"/>
<replace pattern="-" with="_minus_"/>
<replace pattern="\*" with="_star_"/>
<replace pattern="/" with="_slash_"/>
<replace pattern=" " with="_"/>
</xsl:variable>
<xsl:function name="d:cleanup-param">
<xsl:param name="name"/>
<xsl:sequence select="d:perform-replacements($name, $param-replacements)"/>
</xsl:function>
<xsl:function name="d:cleanup-type">
<xsl:param name="name"/>
<xsl:sequence select="d:perform-replacements($name, $type-replacements)"/>
</xsl:function>
<xsl:variable name="param-replacements" select="$additional-param-replacements, $base-param-replacements"/>
<!-- Can be overridden by a customizing stylesheet -->
<xsl:variable name="additional-param-replacements" as="element(replace)*" select="()"/>
<xsl:variable name="base-param-replacements" as="element(replace)*">
<!-- Reformats '*', '&', and '...' in parameters, e.g. "void const*" -->
<replace pattern=" \*$" with="*"/>
<replace pattern=" (&amp;&amp;?)(\.{{3}})?$" with="$1$2"/>
</xsl:variable>
<!-- NOTE: $type-replacements includes $param-replacements -->
<xsl:variable name="type-replacements" select="$additional-type-replacements, $base-type-replacements, $param-replacements"/>
<!-- Can be overridden by a customizing stylesheet -->
<xsl:variable name="additional-type-replacements" as="element(replace)*" select="()"/>
<xsl:variable name="base-type-replacements" as="element(replace)*">
<replace pattern="^virtual$" with=""/>
</xsl:variable>
</xsl:stylesheet>

64
include/docca/config.xsl Normal file
View File

@@ -0,0 +1,64 @@
<xsl:stylesheet version="3.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:d="http://github.com/vinniefalco/docca"
exclude-result-prefixes="xs d"
expand-text="yes">
<xsl:variable name="doc-ns" select="'boost::beast'"/>
<xsl:variable name="doc-ref" select="'beast.ref'"/>
<xsl:variable name="additional-id-replacements" as="element(replace)*">
<replace pattern="boost::asio::error" with=""/>
</xsl:variable>
<xsl:variable name="additional-type-replacements" as="element(replace)*">
<replace pattern="BOOST_ASIO_DECL ?(.*)" with="$1"/>
</xsl:variable>
<xsl:variable name="include-private-members" select="false()"/>
<!-- TODO: refactor the stage-two-specific rules into a separate module that can't intefere with stage one -->
<xsl:template mode="includes-template" match="location"
>Defined in header [include_file {substring-after(@file, 'include/')}]
</xsl:template>
<xsl:template mode="includes-template-footer" match="location">
<xsl:variable name="convenience-header" as="xs:string?">
<xsl:apply-templates mode="convenience-header" select="@file"/>
</xsl:variable>
<xsl:if test="$convenience-header">
<xsl:text>{$nl}</xsl:text>
<xsl:text>Convenience header [include_file boost/beast/{$convenience-header}]</xsl:text>
<xsl:text>{$nl}</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template mode="convenience-header" match="@file[contains(., 'boost/beast/core')]" >core.hpp</xsl:template>
<xsl:template mode="convenience-header" match="@file[contains(., 'boost/beast/http')]" >http.hpp</xsl:template>
<xsl:template mode="convenience-header" match="@file[contains(., 'boost/beast/ssl')]" >ssl.hpp</xsl:template>
<xsl:template mode="convenience-header" match="@file[contains(., 'boost/beast/websocket')]">websocket.hpp</xsl:template>
<xsl:template mode="convenience-header" match="@file[contains(., 'boost/beast/zlib')]" >zlib.hpp</xsl:template>
<xsl:template mode="convenience-header" match="@file"/>
<xsl:function name="d:should-ignore-compound">
<xsl:param name="element" as="element(compound)"/>
<xsl:sequence select="contains($element/name, '::detail')"/> <!-- TODO: Confirm this should be custom and not built-in behavior -->
</xsl:function>
<xsl:function name="d:should-ignore-base">
<xsl:param name="element" as="element(basecompoundref)"/>
<xsl:sequence select="contains($element, '::detail')"/> <!-- TODO: Confirm this should be custom and not built-in behavior -->
</xsl:function>
<xsl:function name="d:should-ignore-inner-class">
<xsl:param name="element" as="element(innerclass)"/>
<xsl:sequence select="contains($element, '_handler')"/>
</xsl:function>
<xsl:function name="d:should-ignore-friend">
<xsl:param name="element" as="element(memberdef)"/>
<xsl:sequence select="contains($element, '_helper')"/>
</xsl:function>
</xsl:stylesheet>

23
include/docca/debug-friendly-quickbook.xsl Normal file
View File

@@ -0,0 +1,23 @@
<!--
All this stylesheet does is output a .txt file for each (erroneously-but-unavoidably-named)
.xml file that actually contains a fragment of Quickbook content. This isn't needed for the
regular build, but it's useful for viewing in the browser when debugging.
-->
<xsl:stylesheet version="3.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
exclude-result-prefixes="xs">
<xsl:output method="text"/>
<xsl:param name="input-dir"/>
<xsl:template match="page">
<xsl:variable name="input-uri" select="$input-dir||'/'||@href"/>
<xsl:result-document href="{replace($input-uri, '\.xml$', '.txt')}">
<xsl:copy-of select="unparsed-text($input-uri)"/>
</xsl:result-document>
<xsl:apply-templates select="page"/>
</xsl:template>
</xsl:stylesheet>

1998
include/docca/doxygen.xsl
View File

File diff suppressed because it is too large Load Diff

43
include/docca/emphasized-types.xsl Normal file
View File

@@ -0,0 +1,43 @@
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
exclude-result-prefixes="xs">
<xsl:variable name="emphasized-template-parameter-types" select="
'Allocator',
'AsyncStream',
'AsyncReadStream',
'AsyncWriteStream',
'Body',
'BufferSequence',
'BufferSequence', (: TODO: Was this intended to be 'BufferSequence_' ?? :)
'CompletionCondition',
'CompletionHandler',
'CompletionToken',
'ConnectCondition',
'ConnectHandler',
'ConstBufferSequence',
'DynamicBuffer',
'EndpointSequence',
'ExecutionContext',
'Executor',
'Executor_',
'Executor1',
'Executor2',
'Fields',
'Handler',
'Handler_',
'IteratorConnectHandler',
'MutableBufferSequence',
'Protocol',
'RangeConnectHandler',
'RatePolicy',
'ReadHandler',
'Stream',
'SyncStream',
'SyncReadStream',
'SyncWriteStream',
'WriteHandler'
"/>
</xsl:stylesheet>

12
include/docca/extract-xml-pages.xsl Normal file
View File

@@ -0,0 +1,12 @@
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:d="http://github.com/vinniefalco/docca"
exclude-result-prefixes="xs d">
<xsl:import href="base-extract-xml-pages.xsl"/>
<!-- TODO: consider refactoring to stage-specific configurations -->
<xsl:include href="config.xsl"/>
</xsl:stylesheet>

11
include/docca/stage1.xsl Normal file
View File

@@ -0,0 +1,11 @@
<xsl:stylesheet version="3.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
exclude-result-prefixes="xs"
expand-text="yes">
<xsl:import href="base-stage1.xsl"/>
<xsl:include href="config.xsl"/>
</xsl:stylesheet>

228
include/docca/stage2.xsl Normal file
View File

@@ -0,0 +1,228 @@
<!DOCTYPE xsl:stylesheet [
<!ENTITY SYNTAX_BLOCK "*[ self::compound
| self::function
| self::typedef
| self::enum
| self::variable
| self::overloaded-member
]">
]>
<xsl:stylesheet version="3.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:d="http://github.com/vinniefalco/docca"
expand-text="yes">
<xsl:output method="text"/>
<xsl:import href="common.xsl"/>
<xsl:include href="config.xsl"/>
<xsl:include href="emphasized-types.xsl"/>
<xsl:param name="DEBUG" select="false()"/>
<xsl:variable name="list-indent-width" select="4"/>
<xsl:template mode="before" match="/page">
<xsl:text>{$nl}</xsl:text>
<xsl:text>[section:{tokenize(@id,'\.')[last()]} {d:qb-escape(title)}]</xsl:text>
<xsl:apply-templates mode="indexterm" select="."/>
</xsl:template>
<xsl:template mode="indexterm" match="page"/>
<xsl:template mode="indexterm" match="page[@primary-index-term]"
>{$nl}[indexterm1 {d:qb-escape(@primary-index-term)}]{$nl}</xsl:template>
<xsl:template mode="indexterm" match="page[@secondary-index-term]" priority="1"
>{$nl}[indexterm2 {d:qb-escape(@primary-index-term)}..{
d:qb-escape(@secondary-index-term)}]{$nl}</xsl:template>
<!-- Title is already included in section header -->
<xsl:template match="/page/title"/>
<xsl:template match="heading">{$nl}[heading {.}]</xsl:template>
<xsl:template match="location">
<xsl:apply-templates mode="includes-template" select="."/>
</xsl:template>
<xsl:template match="footer/location">
<xsl:apply-templates mode="includes-template-footer" select="."/>
</xsl:template>
<xsl:template mode="before" match="&SYNTAX_BLOCK;">{$nl}```{$nl}</xsl:template>
<xsl:template mode="after" match="&SYNTAX_BLOCK;">{$nl}```{$nl}</xsl:template>
<!-- Merge adjacent overloaded-members into one syntax block, separated by one blank line -->
<xsl:template mode="after" match="overloaded-member[following-sibling::*[1]/self::overloaded-member]" priority="1"/>
<xsl:template mode="before" match="overloaded-member[preceding-sibling::*[1]/self::overloaded-member]" priority="1"
>{$nl}{$nl}</xsl:template>
<xsl:template mode="after" match="overloaded-member/type[normalize-space(.)]
| function/type[normalize-space(.)]">{$nl}</xsl:template>
<xsl:template mode="append" match="function">;</xsl:template>
<xsl:template mode="append" match="overloaded-member">
<xsl:text>;{$nl}</xsl:text>
<xsl:variable name="more-link" as="element()">
<emphasis>'''&amp;raquo;''' <ref d:refid="{ref/@d:refid}">more...</ref></emphasis>
</xsl:variable>
<xsl:text> ``</xsl:text>
<xsl:apply-templates select="$more-link"/>
<xsl:text>``</xsl:text>
</xsl:template>
<xsl:template priority="1"
match="&SYNTAX_BLOCK;//ref">``[link {$doc-ref}.{@d:refid} {d:qb-escape(.)}]``</xsl:template>
<xsl:template match="td[1]//ref" >[link {$doc-ref}.{@d:refid} {d:qb-escape(.)}]</xsl:template>
<xsl:template match="ref" >[link {$doc-ref}.{@d:refid} `{d:qb-escape(.)}`]</xsl:template>
<xsl:template mode="before" match="computeroutput[not(ref)] | code">`</xsl:template>
<xsl:template mode="after" match="computeroutput[not(ref)] | code">`</xsl:template>
<xsl:template mode="before" match="enum/name">enum </xsl:template>
<xsl:template mode="before" match="typedef/name">using </xsl:template>
<xsl:template mode="after" match="typedef/name"> = </xsl:template>
<xsl:template mode="after" match="typedef/type">;</xsl:template>
<xsl:template match="type[. eq '__implementation_defined__' ]">``['implementation-defined]``</xsl:template>
<xsl:template match="type[. eq '__see_below__' ]">``['see-below]``</xsl:template>
<xsl:template match="type[. = ('__deduced__','void_or_deduced')]">``__deduced__``</xsl:template>
<xsl:template mode="before" match="variable/name | variable/initializer">{' '}</xsl:template>
<xsl:template mode="append" match="variable">;</xsl:template>
<xsl:template mode="after" match="compound/kind">{' '}</xsl:template>
<xsl:template mode="before" match="base[1]"> :{$nl} </xsl:template>
<xsl:template mode="before" match="base" >{$nl} </xsl:template>
<xsl:template mode="after" match="base[position() ne last()]">,</xsl:template>
<xsl:template mode="after" match="base/prot">{' '}</xsl:template>
<xsl:template mode="before" match="templateparamlist">template&lt;</xsl:template>
<xsl:template mode="after" match="templateparamlist">>{$nl}</xsl:template>
<xsl:template mode="before" match="param">{$nl} </xsl:template>
<xsl:template mode="after" match="param[position() ne last()]">,</xsl:template>
<xsl:template mode="after" match="param[declname]/type">{' '}</xsl:template>
<xsl:template mode="before" match="params">(</xsl:template>
<xsl:template mode="after" match="params">)</xsl:template>
<xsl:template match="templateparamlist/param/declname[. = $emphasized-template-parameter-types]"
>__{translate(.,'_','')}__</xsl:template>
<xsl:template mode="before" match="defval"> = </xsl:template>
<xsl:template mode="before" match="modifier[. eq 'const']">{' '}</xsl:template>
<xsl:template mode="after" match="modifier[. eq 'const']"/>
<xsl:template mode="after" match="modifier">{$nl}</xsl:template>
<xsl:template mode="#all" match="ERROR">[role red error.{@message}]</xsl:template>
<xsl:template mode="before" match="table">{$nl}[table </xsl:template>
<xsl:template mode="after" match="table">{$nl}]</xsl:template>
<!-- ASSUMPTION: table rows have either <th> or <td>, not both -->
<xsl:template mode="before" match="tr[th] | th">[</xsl:template>
<xsl:template mode="after" match="tr[th] | th">]</xsl:template>
<xsl:template mode="before" match="tr">{$nl} [</xsl:template>
<xsl:template mode="after" match="tr">{$nl} ]</xsl:template>
<xsl:template mode="before" match="td">{$nl} [</xsl:template>
<xsl:template mode="after" match="td">{$nl} ]</xsl:template>
<xsl:template mode="before" match="bold">[*</xsl:template>
<xsl:template mode="after" match="bold">]</xsl:template>
<xsl:template mode="before" match="emphasis">['</xsl:template>
<xsl:template mode="after" match="emphasis">]</xsl:template>
<xsl:template mode="before" match="ulink">[@{@url} </xsl:template>
<xsl:template mode="after" match="ulink">]</xsl:template>
<xsl:template mode="after" match="itemizedlist | orderedlist">{$nl}</xsl:template>
<xsl:template match="listitem">
<xsl:text>{$nl}</xsl:text>
<xsl:apply-templates mode="list-item-indent" select="."/>
<xsl:apply-templates mode="list-item-label" select=".."/>
<xsl:text> </xsl:text>
<!-- ASSUMPTION: <para> always appears as a child of list items -->
<xsl:apply-templates select="para/node()"/>
</xsl:template>
<!-- TODO: verify this works as expected (find an example of a nested list) -->
<xsl:template mode="list-item-indent"
match="listitem">{ancestor::listitem ! (1 to $list-indent-width) ! ' '}</xsl:template>
<xsl:template mode="list-item-label" match="itemizedlist">*</xsl:template>
<xsl:template mode="list-item-label" match="orderedlist" >#</xsl:template>
<xsl:template mode="append" match="/page/div[1]">
<xsl:if test="$DEBUG">
<xsl:text>['</xsl:text>
<xsl:text>[role red \[Page type: [*{/*/@type}]\]] </xsl:text>
<xsl:text>[role green \[[@../../doc/html/{translate($doc-ref,'.','/')}/{
translate(/page/@id,'.','/')}.html [role green doc_build_html]]\]] </xsl:text>
<xsl:text>[@../build/xml-pages/{/page/@id}.xml [role blue [*\[doxygen_page_xml\]]]]</xsl:text>
<xsl:text>[@../build/stage1_visualized/visualized/{/page/@id}.html [role magenta ---stage1_visualized-->]]</xsl:text>
<xsl:text>[@../build/stage1_visualized/results/{ /page/@id}.xml [role blue [*\[docca_page_xml\]]]]</xsl:text>
<xsl:text>[@../build/stage2_visualized/visualized/{/page/@id}.html [role magenta ---stage2_visualized-->]]</xsl:text>
<xsl:text>[@../build/stage2_visualized/results/{ /page/@id}.txt [role blue [*\[quickbook_result\]]]]</xsl:text>
<xsl:text>]</xsl:text>
</xsl:if>
</xsl:template>
<xsl:template mode="before" match="para | div">{$nl}</xsl:template>
<xsl:template match="sp">{' '}</xsl:template>
<xsl:template match="linebreak">{$nl}{$nl}</xsl:template>
<xsl:template mode="before" match="programlisting">{$nl}```{$nl}</xsl:template>
<xsl:template mode="after" match="programlisting" >```{$nl}</xsl:template>
<xsl:template mode="after" match="codeline">{$nl}</xsl:template>
<!-- Ignore whitespace-only text nodes -->
<xsl:template match="text()[not(normalize-space())]"/>
<!-- Boilerplate default rules for elements -->
<!-- Convention of this stylesheet is to favor use of just "before" and "after"
and to utilize "append" (and maybe "insert") only when a distinction is needed -->
<xsl:template match="*" priority="10">
<xsl:apply-templates mode="before" select="."/>
<!-- enable if needed/desired
<xsl:apply-templates mode="insert" select="."/> -->
<xsl:next-match/>
<xsl:apply-templates mode="append" select="."/>
<xsl:apply-templates mode="after" select="."/>
</xsl:template>
<!-- Default before/after/insert/append rules are to do nothing -->
<xsl:template mode="before" match="*"/>
<!-- enable if needed/desired
<xsl:template mode="insert" match="*"/> -->
<xsl:template mode="append" match="*"/>
<xsl:template mode="after" match="*"/>
<xsl:function name="d:qb-escape">
<xsl:param name="string"/>
<xsl:sequence select="replace(
replace($string, '\[', '\\['),
'\]',
'\\]'
)"/>
</xsl:function>
</xsl:stylesheet>