mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-26 23:31:55 -08:00
Code Issues Projects Releases Wiki Activity
emacs/mps/manual/html/topic/interface.html
Gareth Rees 28419106ca Build html version of the manual in manual/html. 
Check in HTML version of the manual (writable on client) so that it will display automatically on the Ravenbrook server and so that we can easily include it in product releases.

Copied from Perforce
 Change: 180338
 ServerID: perforce.ravenbrook.com
2012-11-05 17:18:50 +00:00

377 lines
No EOL
26 KiB
HTML
Raw Blame History

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>1. Interface conventions &mdash; Memory Pool System 1.111.0 documentation</title>
<link rel="stylesheet" href="../_static/mps.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '1.111.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<link rel="copyright" title="Copyright" href="../copyright.html" />
<link rel="top" title="Memory Pool System 1.111.0 documentation" href="../index.html" />
<link rel="up" title="Reference" href="index.html" />
<link rel="next" title="2. Error handing" href="error.html" />
<link rel="prev" title="Reference" href="index.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="error.html" title="2. Error handing"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="index.html" title="Reference"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">Memory Pool System 1.111.0 documentation</a> &raquo;</li>
<li><a href="index.html" accesskey="U">Reference</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="interface-conventions">
<span id="topic-interface"></span><span id="index-0"></span><h1>1. Interface conventions<a class="headerlink" href="#interface-conventions" title="Permalink to this headline"></a></h1>
<p>This document describes the conventions used in the programming
interface to the Memory Pool System. It also contains our <a class="reference internal" href="#topic-interface-support"><em>policy
for support for the public identifiers</em></a> and
<a class="reference internal" href="#topic-interface-general"><em>definitions of general types</em></a> that
appear throughout the interface.</p>
<div class="section" id="support-policy">
<span id="topic-interface-support"></span><span id="index-1"></span><h2>1.1. Support policy<a class="headerlink" href="#support-policy" title="Permalink to this headline"></a></h2>
<ol class="arabic">
<li><p class="first">We support the documented behaviour of public symbols in the MPS
interface. We will only remove these symbols or change their
behaviour in a new version, and not in a patch release. Normally
we will give one version&#8217;s notice before removing a symbol or
changing a particular documented behaviour: that is, there will be
a version in which the symbol (or reliance on some of its
behaviour) is deprecated.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">If you are relying on a feature and you see that it&#8217;s
deprecated, please <a class="reference internal" href="../contact.html#contact"><em>contact us</em></a>. It makes a
difference if we know that someone is using a feature.</p>
</div>
</li>
<li><p class="first">Behaviour that is not documented in the <a class="reference internal" href="../guide/index.html#guide"><em>Guide</em></a>,
<a class="reference internal" href="index.html#reference"><em>Reference</em></a>, or <a class="reference internal" href="../pool/index.html#pool"><em>Pool reference</em></a> is not supported and may change
without notice in future releases. In particular, private
identifiers may disappear or their behaviour be changed without
notice in future releases.</p>
</li>
</ol>
</div>
<div class="section" id="language">
<span id="index-2"></span><h2>1.2. Language<a class="headerlink" href="#language" title="Permalink to this headline"></a></h2>
<ol class="arabic simple">
<li>The MPS public interface conforms to ANSI/ISO Standard C (IEC
9899:1990).</li>
</ol>
</div>
<div class="section" id="headers">
<span id="index-3"></span><h2>1.3. Headers<a class="headerlink" href="#headers" title="Permalink to this headline"></a></h2>
<ol class="arabic simple">
<li>The main interface is in the header <tt class="docutils literal"><span class="pre">mps.h</span></tt>. This header
contains all the core MPS interfaces. In practice, you always need
at least one arena class and one pool class header file as well.</li>
<li>We will always prefix public header file names with <tt class="docutils literal"><span class="pre">mps</span></tt> to
avoid clashes. We reserve the right to create new headers
with names beginning with <tt class="docutils literal"><span class="pre">mps</span></tt> in future versions.</li>
<li><a class="reference internal" href="../glossary/p.html#term-pool-class"><em class="xref std std-term">Pool class</em></a> headers have names beginning with <tt class="docutils literal"><span class="pre">mpsc</span></tt>. For
example, the header for <a class="reference internal" href="../pool/amc.html#pool-amc"><em>AMC (Automatic Mostly-Copying)</em></a> is <tt class="docutils literal"><span class="pre">mpscamc.h</span></tt>.</li>
<li><a class="reference internal" href="../glossary/a.html#term-arena-class"><em class="xref std std-term">Arena class</em></a> headers have names beginning with <tt class="docutils literal"><span class="pre">mpsa</span></tt>. For
example, the header for the <a class="reference internal" href="../glossary/v.html#term-virtual-memory-arena"><em class="xref std std-term">virtual memory arena</em></a> class is
<tt class="docutils literal"><span class="pre">mpsavm.h</span></tt>.</li>
</ol>
</div>
<div class="section" id="index-4">
<span id="identifiers"></span><h2>1.4. Identifiers<a class="headerlink" href="#index-4" title="Permalink to this headline"></a></h2>
<ol class="arabic simple">
<li>Identifiers are in lower case, except for preprocessor constants
and macros that do not behave like functions, which are in upper
case. Words are joined by underscores.</li>
<li>All identifiers are either <em>public</em> or <em>private</em>.</li>
<li>The name of public types, functions, variables, and macros start
with <tt class="docutils literal"><span class="pre">mps_</span></tt> or <tt class="docutils literal"><span class="pre">MPS_</span></tt>. The name of public structure members
start with any letter.</li>
<li>Private identifiers start with an underscore <tt class="docutils literal"><span class="pre">_</span></tt>.</li>
<li>Type names end with <tt class="docutils literal"><span class="pre">_t</span></tt>, except for structure and union types.</li>
<li>Structure types and tags end with <tt class="docutils literal"><span class="pre">_s</span></tt>.</li>
<li>Union types and tags end with <tt class="docutils literal"><span class="pre">_u</span></tt>.</li>
</ol>
</div>
<div class="section" id="types">
<span id="index-5"></span><h2>1.5. Types<a class="headerlink" href="#types" title="Permalink to this headline"></a></h2>
<p>There are three kinds of types declared in the MPS interface:
<em>transparent types</em>, <em>opaque types</em>, and <em>derived types</em>. See below.</p>
<ol class="arabic">
<li><p class="first">A <em>transparent type</em> is an alias defined using <tt class="docutils literal"><span class="pre">typedef</span></tt>, and this
is documented so that the <a class="reference internal" href="../glossary/c.html#term-client-program"><em class="xref std std-term">client program</em></a> can rely on that
fact. For example, <a class="reference internal" href="#mps_addr_t" title="mps_addr_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_addr_t</span></tt></a> is a transparent alias for
<tt class="docutils literal"><span class="pre">void</span> <span class="pre">*</span></tt>. Transparent types express intentions in the interface:
in the case of <a class="reference internal" href="#mps_addr_t" title="mps_addr_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_addr_t</span></tt></a> it represents a pointer that
is under the control of the MPS.</p>
</li>
<li><p class="first">An <em>opaque type</em> is a pointer to an incomplete structure type. The
client program must not rely on details of its implementation. For
example, the type <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_arena_t</span></tt></a> is an alias for <tt class="docutils literal"><span class="pre">struct</span>
<span class="pre">mps_arena_s</span> <span class="pre">*</span></tt>, but the implementation of <tt class="docutils literal"><span class="pre">struct</span> <span class="pre">mps_arena_s</span></tt>
is not public.</p>
<p>There are a few structure types that are declared in <tt class="docutils literal"><span class="pre">mps.h</span></tt> but
whose implementation is not public. These only exist so that code
can be inlined using macros. The most important of these is the
<a class="reference internal" href="../glossary/s.html#term-scan-state"><em class="xref std std-term">scan state</em></a> structure <tt class="docutils literal"><span class="pre">mps_ss_s</span></tt>, which is accessed by
scanning macros such as <a class="reference internal" href="scanning.html#MPS_SCAN_BEGIN" title="MPS_SCAN_BEGIN"><tt class="xref c c-func docutils literal"><span class="pre">MPS_SCAN_BEGIN()</span></tt></a> and
<a class="reference internal" href="scanning.html#MPS_FIX12" title="MPS_FIX12"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX12()</span></tt></a>.</p>
</li>
<li><p class="first">A <em>derived type</em> is a structure or function type based on
transparent and opaque types and on built-in C types. The degree
to which you may or must depend upon the implementation of a
derived type is covered by the documentation for the type. For
example, the structure type <a class="reference internal" href="allocation.html#mps_ap_s" title="mps_ap_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_ap_s</span></tt></a> has a mixture of
public and private members.</p>
</li>
</ol>
</div>
<div class="section" id="functions">
<span id="index-6"></span><h2>1.6. Functions<a class="headerlink" href="#functions" title="Permalink to this headline"></a></h2>
<ol class="arabic simple">
<li>Operations that might fail return a <a class="reference internal" href="../glossary/r.html#term-result-code"><em class="xref std std-term">result code</em></a>, rather
than a &#8220;special value&#8221; of the return type. See <a class="reference internal" href="error.html#topic-error"><em>Error handing</em></a>.</li>
<li>A function that needs to return a value as well as a result code
returns the value via an <a class="reference internal" href="../glossary/o.html#term-out-parameter"><em class="xref std std-term">out parameter</em></a>, a parameter that
points to a location to store the result.</li>
<li>A function that stores a result in the location pointed to by an
out parameter only does so if the function is successful (that is,
if the function returns <a class="reference internal" href="error.html#MPS_RES_OK" title="MPS_RES_OK"><tt class="xref c c-macro docutils literal"><span class="pre">MPS_RES_OK</span></tt></a>).</li>
<li>The value in the location pointed to by an out parameter is not
read by the function.</li>
<li>Out parameters have names ending with <tt class="docutils literal"><span class="pre">_o</span></tt>.</li>
<li>A function that both needs to read a value stored in a location and
update the value does so via an <a class="reference internal" href="../glossary/i.html#term-in-out-parameter"><em class="xref std std-term">in/out parameter</em></a>, which is
the same as an out parameter except that the location it points to
is read by the function. See for example <a class="reference internal" href="scanning.html#MPS_FIX12" title="MPS_FIX12"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX12()</span></tt></a>.</li>
<li>In/out parameters have names ending with <tt class="docutils literal"><span class="pre">_io</span></tt>.</li>
</ol>
</div>
<div class="section" id="type-punning">
<span id="topic-interface-pun"></span><span id="index-7"></span><h2>1.7. Type punning<a class="headerlink" href="#type-punning" title="Permalink to this headline"></a></h2>
<p>It&#8217;s tempting to use a type cast to change the type of an in/out or
out parameter, like this:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="cm">/* allocate a struct foo */</span>
<span class="k">struct</span> <span class="n">foo</span> <span class="o">*</span><span class="n">fp</span><span class="p">;</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_alloc</span><span class="p">((</span><span class="n">mps_addr_t</span> <span class="o">*</span><span class="p">)</span><span class="o">&amp;</span><span class="n">fp</span><span class="p">,</span> <span class="n">pool</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">foo</span><span class="p">));</span>
</pre></div>
</div>
<p>This is known as <a class="reference internal" href="../glossary/t.html#term-type-punning"><em class="xref std std-term">type punning</em></a>, and its behaviour is not
defined in ANSI/ISO Standard C. See <a class="reference internal" href="../mmref/bib.html#iso90"><em>ISO/IEC 9899:1990</em></a>
§6.3.2.3, which defines the conversion of a pointer from one type to
another: the behaviour of this cast is not covered by any of the cases
in the standard.</p>
<p>Instead, we recommend this approach:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">mps_addr_t</span> <span class="n">p</span><span class="p">;</span>
<span class="k">struct</span> <span class="n">foo</span> <span class="o">*</span><span class="n">fp</span><span class="p">;</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_alloc</span><span class="p">(</span><span class="o">&amp;</span><span class="n">p</span><span class="p">,</span> <span class="n">pool</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="k">struct</span> <span class="n">foo</span><span class="p">));</span>
<span class="k">if</span><span class="p">(</span><span class="n">res</span><span class="p">)</span> <span class="cm">/* handle error case */</span><span class="p">;</span>
<span class="n">fp</span> <span class="o">=</span> <span class="p">(</span><span class="k">struct</span> <span class="n">foo</span> <span class="o">*</span><span class="p">)</span><span class="n">p</span><span class="p">;</span>
</pre></div>
</div>
<p>This is portable because conversion from <tt class="docutils literal"><span class="pre">void</span> <span class="pre">*</span></tt> to any other
<a class="reference internal" href="../glossary/o.html#term-object-pointer"><em class="xref std std-term">object pointer</em></a> type is defined by <a class="reference internal" href="../mmref/bib.html#iso90"><em>ISO/IEC 9899:1990</em></a> §6.3.2.3.1.</p>
</div>
<div class="section" id="macros">
<span id="index-8"></span><h2>1.8. Macros<a class="headerlink" href="#macros" title="Permalink to this headline"></a></h2>
<ol class="arabic">
<li><p class="first">For function-like macros, the MPS follows the same convention as
the Standard C library. To quote <a class="reference internal" href="../mmref/bib.html#iso90"><em>ISO/IEC 9899:1990</em></a>
§7.1.7:</p>
<blockquote>
<div><p>Any function declared in a header may additionally be
implemented as a macro defined in the header, so a library
function should not be declared explicitly if its header is
included. Any macro definition of a function can be suppressed
locally be enclosing the name of the function in parentheses,
because the name is then not followed by the left parenthesis
that indicates expansion of a macro function name. [...] Any
invocation of a library function that is implemented as a
macro shall expand to code that evaluates each of its
arguments exactly once, fully protected by parentheses where
necessary, so it is generally safe to use arbitrary
expressions as arguments.</p>
</div></blockquote>
</li>
<li><p class="first">Some function-like macros evaluate an argument more than once, so
it is not safe to have a side effect in an argument of such a
method. These special cases are documented. For example,
<a class="reference internal" href="allocation.html#mps_reserve" title="mps_reserve"><tt class="xref c c-func docutils literal"><span class="pre">mps_reserve()</span></tt></a>.</p>
</li>
<li><p class="first">If you need the function rather than the macro, there are two
approaches. You can undefine the macro:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="cp">#undef mps_reserve</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_reserve</span><span class="p">(...);</span> <span class="cm">/* calls function */</span>
</pre></div>
</div>
<p>Or you can put the name in parentheses:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">res</span> <span class="o">=</span> <span class="p">(</span><span class="n">mps_reserve</span><span class="p">)(...);</span> <span class="cm">/* calls function */</span>
</pre></div>
</div>
</li>
<li><p class="first">Statement-like macros have names in uppercase, for example
<a class="reference internal" href="allocation.html#MPS_RESERVE_BLOCK" title="MPS_RESERVE_BLOCK"><tt class="xref c c-func docutils literal"><span class="pre">MPS_RESERVE_BLOCK()</span></tt></a>. These macros behave like statements
rather than expressions, so that you cannot write:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="p">(</span><span class="n">MPS_RESERVE_BLOCK</span><span class="p">(</span><span class="n">res</span><span class="p">,</span> <span class="n">p</span><span class="p">,</span> <span class="n">ap</span><span class="p">,</span> <span class="n">size</span><span class="p">),</span> <span class="mi">0</span><span class="p">)</span>
</pre></div>
</div>
</li>
<li><p class="first">Details of the macro expansion, although visible in the header
file, are not part of the MPS interface, and might change between
releases. Don&#8217;t rely on them, unless they are documented
separately.</p>
</li>
</ol>
</div>
<div class="section" id="general-types">
<span id="topic-interface-general"></span><h2>1.9. General types<a class="headerlink" href="#general-types" title="Permalink to this headline"></a></h2>
<dl class="type">
<dt id="mps_addr_t">
<tt class="descname">mps_addr_t</tt><a class="headerlink" href="#mps_addr_t" title="Permalink to this definition"></a></dt>
<dd><p>The type of <a class="reference internal" href="../glossary/a.html#term-address"><em class="xref std std-term">addresses</em></a> managed by the MPS, and also the
type of <a class="reference internal" href="../glossary/r.html#term-reference"><em class="xref std std-term">references</em></a>.</p>
<p>It is a <a class="reference internal" href="../glossary/t.html#term-transparent-type"><em class="xref std std-term">transparent alias</em></a> for <tt class="docutils literal"><span class="pre">void</span> <span class="pre">*</span></tt>.</p>
<p>It is used in the MPS interface for any pointer that is under the
control of the MPS. In accordance with standard <a class="reference internal" href="../mmref/lang.html#term-c"><em class="xref std std-term">C</em></a>
practice, null pointers of type <a class="reference internal" href="#mps_addr_t" title="mps_addr_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_addr_t</span></tt></a> will never be
used to represent a reference to a block.</p>
</dd></dl>
<dl class="type">
<dt id="mps_align_t">
<tt class="descname">mps_align_t</tt><a class="headerlink" href="#mps_align_t" title="Permalink to this definition"></a></dt>
<dd><p>The type of an <a class="reference internal" href="../glossary/a.html#term-alignment"><em class="xref std std-term">alignment</em></a>.</p>
<p>It is a <a class="reference internal" href="../glossary/t.html#term-transparent-type"><em class="xref std std-term">transparent alias</em></a> for <tt class="docutils literal"><span class="pre">size_t</span></tt>.</p>
<p>An alignment must be a positive power of 2.</p>
</dd></dl>
<dl class="type">
<dt id="mps_bool_t">
<tt class="descname">mps_bool_t</tt><a class="headerlink" href="#mps_bool_t" title="Permalink to this definition"></a></dt>
<dd><p>The type of a Boolean value.</p>
<p>It is a <a class="reference internal" href="../glossary/t.html#term-transparent-type"><em class="xref std std-term">transparent alias</em></a> for <tt class="docutils literal"><span class="pre">int</span></tt>.</p>
<p>When used as an input parameter to the MPS, a value of 0 means
&#8220;false&#8221; and any other value means &#8220;true&#8221;. As an output parameter
or function return from the MPS, 0 means &#8220;false&#8221;, and 1 means
&#8220;true&#8221;.</p>
</dd></dl>
<dl class="type">
<dt id="mps_clock_t">
<tt class="descname">mps_clock_t</tt><a class="headerlink" href="#mps_clock_t" title="Permalink to this definition"></a></dt>
<dd><p>The type of a processor time.</p>
<p>It is a <a class="reference internal" href="../glossary/t.html#term-transparent-type"><em class="xref std std-term">transparent alias</em></a> for
<a class="reference internal" href="#mps_word_t" title="mps_word_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_word_t</span></tt></a>.</p>
<p>This is the type returned by the plinth function
<a class="reference internal" href="plinth.html#mps_clock" title="mps_clock"><tt class="xref c c-func docutils literal"><span class="pre">mps_clock()</span></tt></a>.</p>
</dd></dl>
<dl class="type">
<dt id="mps_word_t">
<tt class="descname">mps_word_t</tt><a class="headerlink" href="#mps_word_t" title="Permalink to this definition"></a></dt>
<dd><p>An unsigned integral type that is the same size as an
<a class="reference internal" href="../glossary/o.html#term-object-pointer"><em class="xref std std-term">object pointer</em></a>, so that <tt class="docutils literal"><span class="pre">sizeof(mps_word_t)</span> <span class="pre">==</span>
<span class="pre">sizeof(void</span> <span class="pre">*)</span></tt>.</p>
<p>The exact identity of this type is
<a class="reference internal" href="../glossary/p.html#term-platform"><em class="xref std std-term">platform</em></a>-dependent. Typical identities are <tt class="docutils literal"><span class="pre">unsigned</span>
<span class="pre">long</span></tt> and <tt class="docutils literal"><span class="pre">unsigned</span> <span class="pre">__int_64</span></tt>.</p>
<div class="admonition-topic admonition">
<p class="first admonition-title">Topic</p>
<p class="last"><a class="reference internal" href="platform.html#topic-platform"><em>Platforms</em></a>.</p>
</div>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<p class="logo"><a href="../index.html">
<img class="logo" src="../_static/logo.png" alt="Logo"/>
</a></p>
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">1. Interface conventions</a><ul>
<li><a class="reference internal" href="#support-policy">1.1. Support policy</a></li>
<li><a class="reference internal" href="#language">1.2. Language</a></li>
<li><a class="reference internal" href="#headers">1.3. Headers</a></li>
<li><a class="reference internal" href="#index-4">1.4. Identifiers</a></li>
<li><a class="reference internal" href="#types">1.5. Types</a></li>
<li><a class="reference internal" href="#functions">1.6. Functions</a></li>
<li><a class="reference internal" href="#type-punning">1.7. Type punning</a></li>
<li><a class="reference internal" href="#macros">1.8. Macros</a></li>
<li><a class="reference internal" href="#general-types">1.9. General types</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="index.html"
title="previous chapter">Reference</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="error.html"
title="next chapter">2. Error handing</a></p><h4>Contact us</h4>
<p class="topless"><a href="mailto:mps-questions@ravenbrook.com">mps-questions@ravenbrook.com</a></p>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="error.html" title="2. Error handing"
>next</a> |</li>
<li class="right" >
<a href="index.html" title="Reference"
>previous</a> |</li>
<li><a href="../index.html">Memory Pool System 1.111.0 documentation</a> &raquo;</li>
<li><a href="index.html" >Reference</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; <a href="../copyright.html">Copyright</a> 2012, Ravenbrook Limited.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
</body>
</html>
Reference in a new issue View git blame Copy permalink