townforge/auto_index
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cc
auto_index/doc/html/boost_autoindex/script_ref.html

519 lines
29 KiB
HTML
Raw Permalink Blame History

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Script File (.idx) Reference</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
<link rel="home" href="../index.html" title="Boost.AutoIndex">
<link rel="up" href="../index.html" title="Boost.AutoIndex">
<link rel="prev" href="tut/refine.html" title="Step 8: Iterate - to refine your index">
<link rel="next" href="workflow.html" title="Understanding The AutoIndex Workflow">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tut/refine.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="workflow.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="boost_autoindex.script_ref"></a><a class="link" href="script_ref.html" title="Script File (.idx) Reference">Script File (.idx) Reference</a>
</h2></div></div></div>
<p>
The following elements can occur in a script:
</p>
<h5>
<a name="boost_autoindex.script_ref.h0"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.comments_and_blank_lines"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.comments_and_blank_lines">Comments
and blank lines</a>
</h5>
<p>
Blank lines consisting of only whitespace are ignored, so are lines that <span class="bold"><strong>start with a #</strong></span>.
</p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
You can't append # comments onto the end of a line!
</p></td></tr>
</table></div>
<h5>
<a name="boost_autoindex.script_ref.h1"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.inclusion_of_index_terms"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.inclusion_of_index_terms">Inclusion
of Index terms</a>
</h5>
<pre class="programlisting"><span class="identifier">term</span> <span class="special">[</span><span class="identifier">regular</span><span class="special">-</span><span class="identifier">expression1</span> <span class="special">[</span><span class="identifier">regular</span><span class="special">-</span><span class="identifier">expression2</span> <span class="special">[</span><span class="identifier">category</span><span class="special">]]]</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">term</span></dt>
<dd>
<p>
<span class="emphasis"><em>Term to index.</em></span>
</p>
<p>
The index term will form a primary entry in the Index with the section
title(s) containing the term as secondary entries, and also will be used
as a secondary entry beneath each of the section titles that the index
term occurs in.
</p>
</dd>
<dt><span class="term">regular-expression1</span></dt>
<dd>
<p>
<span class="emphasis"><em>Index term Searcher.</em></span>
</p>
<p>
An optional regular expression: each occurrence of the regular expression
in the text of the document will result in one index term being emitted.
</p>
<p>
If the regular expression is omitted (default) or is "", then
the <span class="emphasis"><em>index term</em></span> itself will be used as the search
text - and only occurrence of whole words matching <span class="emphasis"><em>index term</em></span>
will be indexed.
</p>
<p>
For example:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">foobar</span></pre>
<p>
</p>
<p>
will index occurrences of "foobar" in any section, but
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">foobar</span> <span class="special">\&lt;\</span><span class="identifier">w</span><span class="special">*(</span><span class="identifier">foo</span><span class="special">|</span><span class="identifier">bar</span><span class="special">)\</span><span class="identifier">w</span><span class="special">*\&gt;</span></pre>
<p>
</p>
<p>
will index any whole word containing either "foo" or "bar"
within it. This is useful when you want to index a lot of similar or
related words under one entry.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">reflex</span></pre>
<p>
</p>
<p>
will only index occurrences of "reflex" as a whole word, but:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">reflex</span> <span class="special">\&lt;</span><span class="identifier">reflex</span><span class="special">\</span><span class="identifier">w</span><span class="special">*\&gt;</span></pre>
<p>
</p>
<p>
will index occurrences of "reflex", "reflexes", "reflexing"
and "reflexed" ... all under the same entry reflex.
</p>
<p>
You will very often need to use this to deal with plurals and other variants.
</p>
</dd>
<dt><span class="term">regular-expression2</span></dt>
<dd>
<p>
<span class="emphasis"><em>Section(s) Selector.</em></span>
</p>
<p>
A constraint that specifies which sections are indexed for <span class="emphasis"><em>term</em></span>:
only if the ID of the section matches <span class="emphasis"><em>regular-expression2</em></span>
exactly will that section be indexed for occurrences of <span class="emphasis"><em>term</em></span>.
</p>
<p>
For example, to limit indexing to just <span class="bold"><strong>one specific
section</strong></span> (but not sub-sections below):
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">myclass</span> <span class="string">""</span> <span class="string">"mylib\.examples"</span></pre>
<p>
</p>
<p>
For example, to limit indexing to specific sections, <span class="bold"><strong>and
sub-sections below</strong></span>:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">myclass</span> <span class="string">""</span> <span class="string">"mylib\.examples.*"</span></pre>
<p>
</p>
<p>
will index occurrences of "myclass" as a whole word, but only
in sections whose section ID <span class="bold"><strong>begins</strong></span>
"mylib.examples", while
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">myclass</span> <span class="string">"\&lt;myclass\w*\&gt;"</span> <span class="string">"mylib\.examples.*"</span></pre>
<p>
</p>
<p>
will also index plurals myclass, myclasses, myclasss ...
</p>
<p>
and:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">myclass</span> <span class="string">""</span> <span class="string">"(?!mylib\.introduction).*"</span></pre>
<p>
</p>
<p>
will index occurrences of "myclass" in any section, except
those whose section IDs begin "mylib.introduction".
</p>
<p>
Finally, two (or more) sections can be excluded by OR'ing them together:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">myclass</span> <span class="string">""</span> <span class="string">"(?!mylib\.introduction|mylib\.reference).*"</span></pre>
<p>
</p>
<p>
which excludes searching for this term in sections whose ID's start with
either "mylib.introduction" or "mylib.reference".
</p>
<p>
If this third section selection field is omitted (the default) or is
"", then <span class="bold"><strong>all sections</strong></span> are
indexed for this term.
</p>
</dd>
<dt><span class="term">category</span></dt>
<dd>
<p>
<span class="emphasis"><em>Index Category Constraint.</em></span>
</p>
<p>
Optionally a category to place occurrences of <span class="emphasis"><em>index term</em></span>
in. If you have multiple indexes then this is the name assigned to the
indexes "type" attribute.
</p>
<p>
For example:
</p>
<p>
myclass "" "" class_name
</p>
<p>
Will index occurances of <span class="emphasis"><em>myclass</em></span> and place them
in the class-index if there is one.
</p>
</dd>
</dl>
</div>
<p>
You can have an index term appear more than once in the script file:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
If they have different <span class="emphasis"><em>category</em></span> names then they are
treated quite separately.
</li>
<li class="listitem">
Otherwise they are combined, so that the logical or of the regular expressions
provided are taken.
</li>
</ul></div>
<p>
Thus:
</p>
<pre class="programlisting"><span class="identifier">myterm</span> <span class="identifier">search_expression1</span> <span class="identifier">constrait_expression2</span> <span class="identifier">foo</span>
<span class="identifier">myterm</span> <span class="identifier">search_expression1</span> <span class="identifier">constrait_expression2</span> <span class="identifier">bar</span>
</pre>
<p>
Will be treated as different terms each with their own entries, while:
</p>
<pre class="programlisting"><span class="identifier">myterm</span> <span class="identifier">search_expression1</span> <span class="identifier">constrait_expression2</span> <span class="identifier">mycategory</span>
<span class="identifier">myterm</span> <span class="identifier">search_expression1</span> <span class="identifier">constrait_expression2</span> <span class="identifier">mycategory</span>
</pre>
<p>
Will be combined into a single term equivalent to:
</p>
<pre class="programlisting"><span class="identifier">myterm</span> <span class="special">(?:</span><span class="identifier">search_expression1</span><span class="special">|</span><span class="identifier">search_expression1</span><span class="special">)</span> <span class="special">(?:</span><span class="identifier">constrait_expression2</span><span class="special">|</span><span class="identifier">constrait_expression2</span><span class="special">)</span> <span class="identifier">mycategory</span>
</pre>
<h5>
<a name="boost_autoindex.script_ref.h2"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.source_file_scanning"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.source_file_scanning">Source
File Scanning</a>
</h5>
<pre class="programlisting"><span class="special">!</span><span class="identifier">scan</span> <span class="identifier">source</span><span class="special">-</span><span class="identifier">file</span><span class="special">-</span><span class="identifier">name</span>
</pre>
<p>
Scans the C/C++ source file <span class="emphasis"><em>source-file-name</em></span> for definitions
of <span class="emphasis"><em>function</em></span>s, <span class="emphasis"><em>class</em></span>s, <span class="emphasis"><em>macro</em></span>s
or <span class="emphasis"><em>typedef</em></span>s and makes each of these a term to be indexed.
Terms found are assigned to the index category "function_name", "class_name",
"macro_name" or "typedef_name" depending on how they were
seen in the source file. These may then be included in a specialised index
whose "type" attribute has the same category name.
</p>
<div class="important"><table border="0" summary="Important">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Important]" src="../../../../../doc/src/images/important.png"></td>
<th align="left">Important</th>
</tr>
<tr><td align="left" valign="top"><p>
When actually indexing a document, the scanner will not index just any old
occurrence of the terms found in the source files. Instead it searches for
class definitions or function or typedef declarations. This reduces the number
of spurious matches placed in the index, but may also miss some legitimate
terms: refer to the <span class="emphasis"><em>define-scanner</em></span> command for information
on how to change this.
</p></td></tr>
</table></div>
<h5>
<a name="boost_autoindex.script_ref.h3"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.directory_and_source_file_scanning"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.directory_and_source_file_scanning">Directory
and Source File Scanning</a>
</h5>
<pre class="programlisting"><span class="special">!</span><span class="identifier">scan</span><span class="special">-</span><span class="identifier">path</span> <span class="identifier">directory</span><span class="special">-</span><span class="identifier">name</span> <span class="identifier">file</span><span class="special">-</span><span class="identifier">name</span><span class="special">-</span><span class="identifier">regex</span> <span class="special">[</span><span class="identifier">recurse</span><span class="special">]</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">directory-name</span></dt>
<dd><p>
The directory to scan: this should be a path relative to the script file
(or to the path specified with the prefix=path option on the command
line) and should use all forward slashes in its file name.
</p></dd>
<dt><span class="term">file-name-regex</span></dt>
<dd><p>
A regular expression: any file in the directory whose name matches the
regular expression will be scanned for terms to index.
</p></dd>
<dt><span class="term">recurse</span></dt>
<dd><p>
An optional boolean value - either "true" or "false"
- that indicates whether to recurse into subdirectories. This defaults
to "false".
</p></dd>
</dl>
</div>
<h5>
<a name="boost_autoindex.script_ref.h4"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.excluding_terms"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.excluding_terms">Excluding
Terms</a>
</h5>
<pre class="programlisting"><span class="special">!</span><span class="identifier">exclude</span> <span class="identifier">term</span><span class="special">-</span><span class="identifier">list</span>
</pre>
<p>
Excludes all the terms in whitespace separated <span class="emphasis"><em>term-list</em></span>
from being indexed. This should be placed <span class="emphasis"><em>after</em></span> any <span class="emphasis"><em>!scan</em></span>
or <span class="emphasis"><em>!scan-path</em></span> rules which may result in the terms becoming
included. In other words this removes terms from the scanners internal list
of things to index.
</p>
<h5>
<a name="boost_autoindex.script_ref.h5"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.rewriting_section_names"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.rewriting_section_names">Rewriting
Section Names</a>
</h5>
<pre class="programlisting">!rewrite-id regular-expression new-name</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">regular-expression</span></dt>
<dd><p>
A regular expression: all section ID's that match the expression exactly
will have index entries <span class="emphasis"><em>new-name</em></span> instead of their
title(s).
</p></dd>
<dt><span class="term">new-name</span></dt>
<dd><p>
The name that the section will appear under in the index.
</p></dd>
</dl>
</div>
<pre class="programlisting"><span class="special">!</span><span class="identifier">rewrite</span><span class="special">-</span><span class="identifier">name</span> <span class="identifier">regular</span><span class="special">-</span><span class="identifier">expression</span> <span class="identifier">format</span><span class="special">-</span><span class="identifier">text</span>
</pre>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">regular-expression</span></dt>
<dd><p>
A regular expression: all sections whose titles match the regular expression
exactly, will have index entries composed of the regular expression match
combined with the regex format string <span class="emphasis"><em>format-text</em></span>.
</p></dd>
<dt><span class="term">format-text</span></dt>
<dd><p>
The Perl-style format string used to reformat the title.
</p></dd>
</dl>
</div>
<p>
For example:
</p>
<pre class="programlisting">!rewrite-name "(?:A|An|The)\s+(.*)" "\1"
</pre>
<p>
Will remove any leading "A", "An" or "The" from
all index entries - thus preventing lots of entries under "The" etc!
</p>
<h5>
<a name="boost_autoindex.script_ref.h6"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.defining_or_changing_the_file_scanners"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.defining_or_changing_the_file_scanners">Defining
or Changing the File Scanners</a>
</h5>
<pre class="programlisting"><span class="special">!</span><span class="identifier">define</span><span class="special">-</span><span class="identifier">scanner</span> <span class="identifier">type</span> <span class="identifier">file</span><span class="special">-</span><span class="identifier">search</span><span class="special">-</span><span class="identifier">expression</span> <span class="identifier">xml</span><span class="special">-</span><span class="identifier">regex</span><span class="special">-</span><span class="identifier">formatter</span> <span class="identifier">term</span><span class="special">-</span><span class="identifier">formatter</span> <span class="identifier">id</span><span class="special">-</span><span class="identifier">filter</span> <span class="identifier">filename</span><span class="special">-</span><span class="identifier">filter</span>
</pre>
<p>
When a source file is scanned using the <code class="literal">!scan</code> or <code class="literal">!scan-path</code>
rules, then the file is searched using a series of regular expressions to look
for classes, functions, macros or typedefs that should be indexed. A set of
default regular expressions are provided for this (see below), but sometimes
you may want to replace the defaults, or add new scanners. The arguments to
this rule are:
</p>
<div class="variablelist">
<p class="title"><b></b></p>
<dl class="variablelist">
<dt><span class="term">type</span></dt>
<dd><p>
The <span class="emphasis"><em>type</em></span> to which items found using this rule will
assigned, index terms created from the source file and then found in
the XML, will have the type attribute set to this value, and may then
appear in a specialized index with the same type attribute
</p></dd>
<dt><span class="term">file-search-expression</span></dt>
<dd><p>
A regular expression that is used to scan the source file for index terms,
the result of a match against this expression will be transformed by
the next two arguments.
</p></dd>
<dt><span class="term">xml-regex-formatter</span></dt>
<dd><p>
A regular expression format string that extracts the salient information
from whatever matched the <span class="emphasis"><em>file-search-expression</em></span>
in the source file, and creates <span class="emphasis"><em>a new regular expression</em></span>
that will be used to search the document being indexed for occurrences
of this index term.
</p></dd>
<dt><span class="term">term-formatter</span></dt>
<dd><p>
A regular expression format string that extracts the salient information
from whatever matched the <span class="emphasis"><em>file-search-expression</em></span>
in the source file, and creates the index term that will appear in the
index.
</p></dd>
<dt><span class="term">id-filter</span></dt>
<dd><p>
Optional. A regular expression that restricts the section-id's that are
searched in the document being indexed: only sections whose ID attribute
matches this expression exactly will be considered for indexing terms
found by this scanner.
</p></dd>
<dt><span class="term">filename-filter</span></dt>
<dd><p>
Optional. A regular expression that restricts which files are scanned
by this scanner: only files whose file name matches this expression exactly
will be scanned for index terms to use. Note that the filename matched
against this may well be an absolute path, and contain either forward
or backward slash path separators.
</p></dd>
</dl>
</div>
<p>
If, when the first file is scanned, there are no scanners whose <span class="emphasis"><em>type</em></span>
is "class_name", "typedef_name", "macro_name"
or "function_name", then the defaults are installed. These are equivalent
to:
</p>
<pre class="programlisting"><span class="special">!</span><span class="identifier">define</span><span class="special">-</span><span class="identifier">scanner</span> <span class="identifier">class_name</span> <span class="string">"^[[:space:]]*(template[[:space:]]*&lt;[^;:{]+&gt;[[:space:]]*)?(class|struct)[[:space:]]*(\&lt;\w+\&gt;([[:blank:]]*\([^)]*\))?[[:space:]]*)*(\&lt;\w*\&gt;)[[:space:]]*(&lt;[^;:{]+&gt;)?[[:space:]]*(\{|:[^;\{()]*\{)"</span> <span class="string">"(?:class|struct)[^;{]+\&lt;\5\&gt;[^;{]+\{"</span> <span class="special">\</span><span class="number">5</span>
<span class="special">!</span><span class="identifier">define</span><span class="special">-</span><span class="identifier">scanner</span> <span class="identifier">typedef_name</span> <span class="string">"typedef[^;{}#]+?(\w+)\s*;"</span> <span class="string">"typedef[^;]+\&lt;\1\&gt;\s*;"</span> <span class="string">"\1"</span>
<span class="special">!</span><span class="identifier">define</span><span class="special">-</span><span class="identifier">scanner</span> <span class="string">"macro_name"</span> <span class="string">"^\s*#\s*define\s+(\w+)"</span> <span class="string">"\&lt;\1\&gt;"</span> <span class="string">"\1"</span>
<span class="special">!</span><span class="identifier">define</span><span class="special">-</span><span class="identifier">scanner</span> <span class="string">"function_name"</span> <span class="string">"\w++(?:\s*+&lt;[^&gt;]++&gt;)?[\s&amp;*]+?(\w+)\s*(?:BOOST_[[:upper:]_]+\s*)?\([^;{}]*\)\s*[;{]"</span> <span class="string">"\\&lt;\\w+\\&gt;(?:\\s+&lt;[^&gt;]*&gt;)*[\\s&amp;*]+\\&lt;\1\\&gt;\\s*\\([^;{]*\\)"</span> <span class="string">"\1"</span>
</pre>
<p>
Note that these defaults are not installed if you have provided your own versions
with these <span class="emphasis"><em>type</em></span> names. In this case if you want the default
scanners to be in effect as well as your own, you should include the above
in your script file. It is also perfectly allowable to have multiple scanners
with the same <span class="emphasis"><em>type</em></span>, but with the other fields differing.
</p>
<p>
Finally you should note that the default scanners are quite strict in what
they will find, for example the class scanner will only create index entries
for classes that have class definitions of the form:
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">my_class</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">base_classes</span>
<span class="special">{</span>
<span class="comment">// etc</span>
</pre>
<p>
In the documentation, so that simple mentions of the class name will <span class="emphasis"><em>not</em></span>
get indexed, only the class synopsis if there is one. If this isn't how you
want things, then include the <span class="emphasis"><em>class_name</em></span> scanner definition
above in your script file, and change the <span class="emphasis"><em>xml-regex-formatter</em></span>
field to something more permissive, for example:
</p>
<pre class="programlisting"><span class="special">!</span><span class="identifier">define</span><span class="special">-</span><span class="identifier">scanner</span> <span class="identifier">class_name</span> <span class="string">"^[[:space:]]*(template[[:space:]]*&lt;[^;:{]+&gt;[[:space:]]*)?(class|struct)[[:space:]]*(\&lt;\w+\&gt;([[:blank:]]*\([^)]*\))?[[:space:]]*)*(\&lt;\w*\&gt;)[[:space:]]*(&lt;[^;:{]+&gt;)?[[:space:]]*(\{|:[^;\{()]*\{)"</span> <span class="string">"\&lt;\5\&gt;"</span> <span class="special">\</span><span class="number">5</span>
</pre>
<p>
Will look for <span class="emphasis"><em>any</em></span> occurrence of whatever class names the
scanner may find in the documentation.
</p>
<h5>
<a name="boost_autoindex.script_ref.h7"></a>
<span class="phrase"><a name="boost_autoindex.script_ref.debugging_scanning"></a></span><a class="link" href="script_ref.html#boost_autoindex.script_ref.debugging_scanning">Debugging
scanning</a>
</h5>
<p>
If you see a term in the index, and you don't understand why it's there, add
a <span class="emphasis"><em>debug</em></span> directive:
</p>
<pre class="programlisting">!debug regular-expression
</pre>
<p>
Now, whenever <span class="emphasis"><em>regular-expression</em></span> matches either the found
index term, or the section title it appears in, or the <span class="emphasis"><em>type</em></span>
field of a scanner, then some diagnostic information will be printed that will
look something like:
</p>
<pre class="programlisting">Debug term found, in block with ID: spirit.qi.reference.parser_concepts.parser
Current section title is: Notation
The main index entry will be : Notation
The indexed term is: parser
The search regex is: [P|p]arser
The section constraint is: .<span class="bold"><strong>qi.reference.parser_concepts.</strong></span>
The index type for this entry is: qi_index
</pre>
<p>
This can produce a lot of output in your log file, but until you are satisfied
with your file selection and scanning process, it is worth switching it on.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright &#169; 2008, 2011 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tut/refine.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="workflow.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink