Github/emacs
2
0
Fork 1
mirror of git://git.sv.gnu.org/emacs.git synced 2026-02-21 04:17:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Updated manual html

Browse source 
Copied from Perforce
 Change: 182591
 ServerID: perforce.ravenbrook.com
This commit is contained in:
Richard Brooksby 2013-06-06 20:59:14 +01:00
parent 326bc67f83
commit e940ea3732
93 changed files with 2864 additions and 1243 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
mps/manual/html/_downloads/scheme-advanced.c
View file

@ -198,8 +198,8 @@ typedef struct table_s {
/* fwd2, fwd, pad1, pad -- MPS forwarding and padding objects %%MPS
*
* These object types are here to satisfy the MPS Format Protocol
* for format variant "A". See topic/format.
* These object types are here to satisfy the MPS Format Protocol.
* See topic/format.
*
* The MPS needs to be able to replace any object with a forwarding
* object or broken heart and since the smallest normal object defined
@ -1715,7 +1715,7 @@ static obj_t entry_quote(obj_t env, obj_t op_env, obj_t operator, obj_t operands
static obj_t entry_define(obj_t env, obj_t op_env, obj_t operator, obj_t operands)
{
obj_t symbol, value;
obj_t symbol = NULL, value = NULL;
unless(TYPE(operands) == TYPE_PAIR &&
TYPE(CDR(operands)) == TYPE_PAIR)
error("%s: illegal syntax", operator->operator.name);
@ -3479,7 +3479,7 @@ static obj_t entry_eqv_hash(obj_t env, obj_t op_env, obj_t operator, obj_t opera
static obj_t make_hashtable(obj_t operator, obj_t rest, hash_t hashf, cmp_t cmpf, int weak_key, int weak_value)
{
size_t length;
size_t length = 0;
if (rest == obj_empty)
length = 8;
else unless(CDR(rest) == obj_empty)
@ -3889,8 +3889,7 @@ static struct {char *name; entry_t entry;} funtab[] = {
/* MPS Format %%MPS
*
* These functions satisfy the MPS Format Protocol for format
* variant "A". See topic/format.
* These functions describe Scheme objects to the MPS. See topic/format.
*
* In general, MPS format methods are performance critical, as they're used
* on the MPS critical path. See topic/critical.
@ -4138,23 +4137,6 @@ static void obj_pad(mps_addr_t addr, size_t size)
}
/* obj_fmt_s -- object format parameter structure %%MPS
*
* This is simply a gathering of the object format methods and the chosen
* pool alignment for passing to `mps_fmt_create_A`. See topic/format.
*/
struct mps_fmt_A_s obj_fmt_s = {
ALIGNMENT,
obj_scan,
obj_skip,
NULL, /* Obsolete copy method */
obj_fwd,
obj_isfwd,
obj_pad
};
/* buckets_scan -- buckets format scan method %%MPS
*/
@ -4221,20 +4203,6 @@ static mps_addr_t buckets_find_dependent(mps_addr_t addr)
}
/* buckets_fmt_s -- buckets format parameter structure %%MPS
*/
struct mps_fmt_A_s buckets_fmt_s = {
ALIGNMENT,
buckets_scan,
buckets_skip,
NULL, /* Obsolete copy method */
NULL, /* fwd method not used by AWL */
NULL, /* isfwd method not used by AWL */
NULL /* pad method not used by AWL */
};
/* globals_scan -- scan static global variables %%MPS
*
* The static global variables are all used to hold values that are set
@ -4477,8 +4445,19 @@ int main(int argc, char *argv[])
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create arena");
/* Create the object format. */
res = mps_fmt_create_A(&obj_fmt, arena, &obj_fmt_s);
/* Create the object format. This gathers together the methods that
the MPS uses to interrogate your objects via the Format Protocol.
See topic/format. */
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, ALIGNMENT);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, obj_scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, obj_skip);
MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, obj_fwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, obj_isfwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, obj_pad);
MPS_ARGS_DONE(args);
res = mps_fmt_create_k(&obj_fmt, arena, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create obj format");
/* Create a chain controlling GC strategy. FIXME: explain! */
@ -4520,7 +4499,12 @@ int main(int argc, char *argv[])
if (res != MPS_RES_OK) error("Couldn't create leaf objects allocation point");
/* Create the buckets format. */
res = mps_fmt_create_A(&buckets_fmt, arena, &buckets_fmt_s);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, ALIGNMENT);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, buckets_scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, buckets_skip);
res = mps_fmt_create_k(&buckets_fmt, arena, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create buckets format");
/* Create an Automatic Weak Linked (AWL) pool to manage the hash table
@ -4581,6 +4565,7 @@ int main(int argc, char *argv[])
check final consistency and warn you about bugs. It also allows the
MPS to flush buffers for debugging data, etc. It's good practise
to destroy MPS objects on exit if possible rather than just quitting. */
mps_arena_park(arena);
mps_root_destroy(reg_root);
mps_thread_dereg(thread);
mps_ap_destroy(strong_buckets_ap);

4
mps/manual/html/_downloads/scheme-malloc.c
View file

@ -1445,7 +1445,7 @@ static obj_t entry_quote(obj_t env, obj_t op_env, obj_t operator, obj_t operands
static obj_t entry_define(obj_t env, obj_t op_env, obj_t operator, obj_t operands)
{
obj_t symbol, value;
obj_t symbol = NULL, value = NULL;
unless(TYPE(operands) == TYPE_PAIR &&
TYPE(CDR(operands)) == TYPE_PAIR)
error("%s: illegal syntax", operator->operator.name);
@ -3212,7 +3212,7 @@ static obj_t entry_eqv_hash(obj_t env, obj_t op_env, obj_t operator, obj_t opera
static obj_t make_hashtable(obj_t operator, obj_t rest, hash_t hashf, cmp_t cmpf)
{
size_t length;
size_t length = 0;
if (rest == obj_empty)
length = 8;
else unless(CDR(rest) == obj_empty)

44
mps/manual/html/_downloads/scheme.c
View file

@ -195,8 +195,8 @@ typedef struct buckets_s {
/* fwd2, fwd, pad1, pad -- MPS forwarding and padding objects %%MPS
*
* These object types are here to satisfy the MPS Format Protocol
* for format variant "A". See topic/format.
* These object types are here to satisfy the MPS Format Protocol.
* See topic/format.
*
* The MPS needs to be able to replace any object with a forwarding
* object or broken heart and since the smallest normal object defined
@ -1744,7 +1744,7 @@ static obj_t entry_quote(obj_t env, obj_t op_env, obj_t operator, obj_t operands
static obj_t entry_define(obj_t env, obj_t op_env, obj_t operator, obj_t operands)
{
obj_t symbol, value;
obj_t symbol = NULL, value = NULL;
unless(TYPE(operands) == TYPE_PAIR &&
TYPE(CDR(operands)) == TYPE_PAIR)
error("%s: illegal syntax", operator->operator.name);
@ -3508,7 +3508,7 @@ static obj_t entry_eqv_hash(obj_t env, obj_t op_env, obj_t operator, obj_t opera
static obj_t make_hashtable(obj_t operator, obj_t rest, hash_t hashf, cmp_t cmpf)
{
size_t length;
size_t length = 0;
if (rest == obj_empty)
length = 8;
else unless(CDR(rest) == obj_empty)
@ -3866,8 +3866,7 @@ static struct {char *name; entry_t entry;} funtab[] = {
/* MPS Format %%MPS
*
* These functions satisfy the MPS Format Protocol for format
* variant "A". See topic/format.
* These functions describe Scheme objects to the MPS. See topic/format.
*
* In general, MPS format methods are performance critical, as they're used
* on the MPS critical path. See topic/critical.
@ -4132,23 +4131,6 @@ static void obj_pad(mps_addr_t addr, size_t size)
}
/* obj_fmt_s -- object format parameter structure %%MPS
*
* This is simply a gathering of the object format methods and the chosen
* pool alignment for passing to `mps_fmt_create_A`. See topic/format.
*/
struct mps_fmt_A_s obj_fmt_s = {
ALIGNMENT,
obj_scan,
obj_skip,
NULL, /* Obsolete copy method */
obj_fwd,
obj_isfwd,
obj_pad
};
/* globals_scan -- scan static global variables %%MPS
*
* The static global variables are all used to hold values that are set
@ -4398,8 +4380,19 @@ int main(int argc, char *argv[])
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create arena");
/* Create the object format. */
res = mps_fmt_create_A(&obj_fmt, arena, &obj_fmt_s);
/* Create the object format. This gathers together the methods that
the MPS uses to interrogate your objects via the Format Protocol.
See topic/format. */
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, ALIGNMENT);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, obj_scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, obj_skip);
MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, obj_fwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, obj_isfwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, obj_pad);
MPS_ARGS_DONE(args);
res = mps_fmt_create_k(&obj_fmt, arena, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create obj format");
/* Create a chain controlling GC strategy. FIXME: explain! */
@ -4460,6 +4453,7 @@ int main(int argc, char *argv[])
check final consistency and warn you about bugs. It also allows the
MPS to flush buffers for debugging data, etc. It's good practise
to destroy MPS objects on exit if possible rather than just quitting. */
mps_arena_park(arena);
mps_root_destroy(reg_root);
mps_thread_dereg(thread);
mps_ap_destroy(obj_ap);

4
mps/manual/html/_sources/design/arenavm.txt
View file

@ -199,7 +199,9 @@ tables.
[missing figure]
:mps:tag:`fig.count` How a count table can be used to partially map the page
table, as proposed in request.dylan.170049.sol.map.
table, as proposed in request.dylan.170049.sol.map_.
.. _request.dylan.170049.sol.map: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170049
[missing figure]

16
mps/manual/html/_sources/design/bt.txt
View file

@ -625,7 +625,7 @@ the range to be found, the other the maximum length. For
:mps:tag:`fun.find-res-range` :c:func:`BTFindResRange()`. Iterate within the search
boundaries, identifying candidate ranges by searching for a reset bit.
The :ref:`Boyer–Moore algorithm <BM77>` is used (it's particularly
The Boyer–Moore algorithm [Boyer_Moore_1977]_ is used (it's particularly
easy to implement when there are only two symbols, 0 and 1, in the
alphabet). For each candidate range, iterate backwards over the bits
from the end of the range towards the beginning. If a set bit is
@ -650,9 +650,11 @@ word or subword.
:mps:tag:`fun.find-res-range.improve` Various other performance improvements
have been suggested in the past, including some from
request.epcore.170534. Here is a list of potential improvements which
all sound plausible, but which have not led to performance
improvements in practice:
request.epcore.170534_. Here is a list of potential improvements which
all sound plausible, but which have not led to performance improvements
in practice:
.. _request.epcore.170534: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/170534
* :mps:tag:`fun.find-res-range.improve.step.partial` When the top index in a
candidate range fails, skip partial words as well as whole words,
@ -707,3 +709,9 @@ Tables more extensively. See change.mps.epcore.brisling.160181 TEST1
and TEST2.
References
----------
.. [Boyer_Moore_1977] Robert S. Boyer and J. Strother Moore. Communications of the ACM 20(10):762–772. 1977. "`A Fast String Searching Algorithm <http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf>`__".

4
mps/manual/html/_sources/design/buffer.txt
View file

@ -111,7 +111,9 @@ Requirements
Actually not a requirement any more, but once was put forward as a
Dylan requirement. Bits of the code still reflect this
requirement. See request.dylan.170554.
requirement. See request.dylan.170554_.
.. _request.dylan.170554: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170554
Classes

6
mps/manual/html/_sources/design/config.txt
View file

@ -178,12 +178,6 @@ upper case. Currently (2012-09-03):
bugs. We do not advise use of this variety, as memory management
bugs tend to be extremely expensive to deal with.
:mps:tag:`var.diag` :c:macro:`DIAG` (deprecated)
This variety does some client-specific analysis and produces some
specialised diagnostic output, and is not intended for general use.
It will be phased out of the open sources.
:mps:tag:`default.hot` If no :c:macro:`CONFIG_VAR` is present, :c:macro:`HOT` is assumed in
`config.h`_.

220
mps/manual/html/_sources/design/diag.txt
View file

@ -24,14 +24,14 @@ Overview
--------
Diagnostic feedback is information created by the MPS diagnostic
system for the purpose of helping MPS programmers client-code
system for the purpose of helping MPS programmers and client
programmers.
Such a piece of information is called "a diagnostic". (See also
:mps:ref:`.parts`.)
A diagnostic is not intended to be end-user readable (or visible), or
machine-parseable.
A diagnostic is not intended to be visible to end users, or readable
by them.
A diagnostic is not intended to be stable from one release to the
next: it may be modified or removed at any time.
@ -47,203 +47,78 @@ MPS diagnostic feedback code must do these things:
- control (for example, filter) output of diagnostics;
- use a channel to get the diagnostic out.
Note: the knowledge/code/logic for constructing the human-useful
message is kept inside normal MPS source code. This means it is always
in-sync with changes to the MPS. This also means that any external
utilities used to display the messages do not need to understand, or
keep in sync with, the details of what's going inside the MPS.
Usage
-----
To run the MPS and get diagnostic output from it:
To get diagnostic output from the MPS, you must use a variety with
diagnostics compiled-in. Currently, that means variety.cool. See
``config.h``.
1. Use a variety with diagnostics compiled-in. Currently, that means
variety.di. See ``config.h``.
There are two mechanism for getting diagnostic output:
2. Check that the diagnostics you require are generated, by looking in
MPS source for invocations of the appropriate macro (for example,
:c:func:`DIAG_SINGLEF()`).
1. Automatically via the telemetry system. See design.mps.telemetry,
and the "Telemetry" chapter in the manual.
3. Check that the diagnostics you require will be output, by looking
at the diagnostic filter rules in ``diag.c``.
2. Manually via the debugger. In the debugger, set break points at the
places where you want to inspect data structures (or wait for the
debugger to be entered via an :c:func:`abort()` call or unhandled
segmentation fault). Then at the debugger command prompt, run
:c:func:`Describe()` commands of your choice. For example::
4. Run the MPS and client in an environment that supports the channel
used (for example, at a command-line if using :c:func:`WriteF()`).
(gdb) run
Starting program: mv2test
Reading symbols for shared libraries +............................. done
cbs.c:94: MPS ASSERTION FAILED: !cbs->inCBS
What is a diagnostic?
.....................
A diagnostic has three parts:
1. a trigger condition, that causes this diagnostic to be emitted;
2. a text tag (for example, "TraceStart") which is the name of this
diagnostic; and
3. a paragraph of human-useful text.
A diagnostic is emitted by the MPS at a certain point in time when a
certain event happens.
Diagnostics are not nested. Every diagnostic must have a tag. Each
diagnostic should have a unique tag (uniqueness is just to help the
humans; the diagnostic system does not care).
The paragraph of text can be many lines long. It usually explains what
event caused the diagnostic to be emitted, and commonly also includes
the output of some :c:func:`Describe()` methods for various relevant
objects. (For example, the ``TraceStart`` diagnostic might call, and
include the output generated by, the :c:func:`TraceDescribe()` method).
How do I control (filter) which diagnostics I see?
..................................................
All diagnostics are emitted and then filtered according to the
"diagnostic filter rules".
The first level of control is filtering by tag. (For example, only
show ``TraceStart`` diagnostics).
The second level of control is filtering by paragraph content. (For
example, only show ``TraceStart`` diagnostics where the trace is
started because a nursery generation is full).
The third level of control is filtering by line content. (For example,
only show lines containing the word ``whiteSet``).
See ``diag.c`` for details.
Note: the entire filtering mechanism can be turned off, so that
diagnostics go immediately to ``mps_lib_get_stdout(0``, with no
buffering or filtering See impl.c.diag.filter-disable.
Program received signal SIGABRT, Aborted.
0x00007fff83e42d46 in __kill ()
(gdb) frame 12
#12 0x000000010000b1fc in MVTFree (pool=0x103ffe160, base=0x101dfd000, size=5024) at poolmv2.c:711
711 Res res = CBSInsert(MVTCBS(mvt), base, limit);
(gdb) p MVTDescribe(mvt, mps_lib_get_stdout())
MVT 0000000103FFE160
{
minSize: 8
meanSize: 42
maxSize: 8192
fragLimit: 30
reuseSize: 16384
fillSize: 8192
availLimit: 1110835
abqOverflow: FALSE
splinter: TRUE
splinterSeg: 0000000103FEE780
splinterBase: 0000000101D7ABB8
splinterLimit: 0000000101D7B000
# ... etc ...
}
How to write a diagnostic
-------------------------
Improve stateless Describe methods where possible
.................................................
Where possible, don't put clever code into an event-triggered
diagnostic: put it into a stateless :c:func:`Describe()` method instead, and
then call that method when emitting your diagnostic.
For example::
FooDescribe(Foo foo, mps_lib_FILE *stream)
{
/* show value of new "quux" field */
WriteF(stream, "Foo: $P { quux: $U }\n", foo, foo->quux);
}
FooWibble(Foo foo)
{
...
DIAG_FIRSTF(( "FooWibble", "Wibbling foo $P", foo, NULL));
DIAG( FooDescribe(foo, DIAG_STREAM); );
DIAG_END("FooWibble");
...
}
This is much better, because other people can use your human-useful
output in their diagnostics, or 'live' in a debugger.
Use the output macros
.....................
For a simple diagnostic, use :c:func:`DIAG_SINGLEF()`. This begins the tag,
puts text into the paragraph, and ends the tag immediately.
For a more complex diagnostic, the first call must be
:c:func:`DIAG_FIRSTF()`, which begins a diag tag.
While a tag is current, you can add text to the diagnostic's paragraph
using :c:func:`DIAG_MOREF()`, and ``WriteF( DIAG_STREAM, ... )``.
.. note::
:c:macro:`DIAG_STREAM` is not a real standard C library stream. If you
want stream-level access, you may use :c:func:`Stream_fputc()` and
:c:func:`Stream_fputs()`.
End the tag by calling :c:macro:`DIAG_END`.
Compile away in non-diag varieties; no side effects
...................................................
Wrap non-output code with the :c:func:`DIAG()` and :c:func:`DIAG_DECL()` macros,
to make sure that non-diag varieties do not execute
diagnostic-generating code.
Wrap code with the :c:macro:`STATISTIC` and :c:macro:`METER` macros, to make sure
that non-diagnostic varieties do not execute diagnostic-generating
code.
For complex diagnostic-generating code, it may be cleaner to move it
into a separate local function. Put ``_diag`` on the end of the function
name (for example, :c:func:`TraceStart_diag()`).
Obviously, diagnostic-generating code must have no side effects.
Choosing tags
.............
Tags should be valid C identifiers. Unless you know of a good reason
why not. (Not currently checked).
There's no formal scheme for tag naming, but make it helpful and
informally hierarchical, for example, ``TraceBegin``, ``TraceStart``,
``TraceEnd``, and so on, not ``BeginTrace``, ``EndTrace``.
Diagnostic-generating code must have no side effects.
Writing good paragraph text
...........................
IMPORTANT: Make your diagnostics easy to understand! Other people will
read your diagnostics! Make them clear and helpful. Do not make them
terse and cryptic. If you use symbols, print a key in the diagnostic.
(If you don't want to see this the screen clutter, then you can always
add a filter rule to your personal rule set to filter it out).
Maintaining helpful filter rules
................................
If you add a noisy diagnostic, add a rule to the default ruleset to
turn it off.
Make your diagnostics easy to understand! Other people will read your
diagnostics! Make them clear and helpful. Do not make them terse and
cryptic. If you use symbols, print a key in the diagnostic.
How the MPS diagnostic system works
-----------------------------------
Channels
........
The recommended channel is :c:func:`WriteF()` to standard output.
Other possible of future channels might be:
- :c:func:`printf()`;
- a new type (yet to be defined) of ``mps_message``;
- squirt them into the telemetry-log-events system;
- telnet.
Currently, only :c:func:`printf()` and :c:func:`WriteF()` are supported. See the
:c:macro:`DIAG_WITH_` macros in ``mpm.h``.
You can also use a debugger to call :c:func:`Describe()` methods directly,
from within the debugger.
Note: it is unfortunate that choice of channel may (for some channels)
also dictate the form of the code that synthesises the message. (For
example, :c:func:`WriteF()` style parameter-expansion is not possible when
using the :c:func:`printf()` channel, because there is no way to get
:c:func:`WriteF()` to produce its output into a string). This is just a
technical hitch; logically, the code that synthesises a diagnostic
message should not care which channel will be used to transmit it out
of the MPS.
Parts of the MPS diagnostic system
..................................
@ -251,7 +126,6 @@ Parts of the MPS diagnostic system
diagnostic system:
- the :c:func:`Describe()` methods.
- the :c:macro:`DIAG` macros (:c:macro:`DIAG`, :c:macro:`DIAG_DECL`, ``DIAG_*F``, and so on);
- the :c:macro:`STATISTIC` macros (see ``mpm.h``);
- the :c:macro:`METER` macros and meter subsystem.

10
mps/manual/html/_sources/design/message-gc.txt
View file

@ -74,9 +74,10 @@ be extra content that is only meaningful to MPS staff, to help us
diagnose client problems.
While there is some overlap with the Diagnostic Feedback system
(design.mps.diag), the main contrasts are that these GC messages are
present in release builds, are stable from release to release, and are
designed to be parsed by the client program.
(design.mps.diag) and the Telemetry system (design.mps.telemetry), the
main contrasts are that these GC messages are present in release
builds, are stable from release to release, and are designed to be
parsed by the client program.
Names and parts
@ -226,8 +227,7 @@ for the next collection using this trace id, neither a start nor an
end message will be sent (:mps:ref:`.req.match`). There is no direct way to
report this failure to the client (:mps:ref:`.req.errors-not-direct`), so we
just increment the ``droppedMessages`` counter in the :c:type:`ArenaStruct`.
Currently this counter is never reported to the client (except in
diagnostic varieties).
This counter is available via the ``MessagesDropped`` telemetry event.
Getting and discarding

17
mps/manual/html/_sources/design/poolamc.txt
View file

@ -293,13 +293,12 @@ Feedback about retained pages
(New with job001811_). AMC now accumulates counts of pages condemned
and retained during a trace, in categories according to size and
reason for retention, and emits diagnostic at trace-end via the
``pool->class->traceEnd`` method. See comments on the
:c:type:`PageRetStruct` in poolamc.c. These page-based metrics are not as
precise as actually counting the size of objects, but they require
much less intrusive code to implement, and should be sufficient to
assess whether AMC's page retention policies and behaviour are
acceptable.
reason for retention, and emits this via the ``AMCTraceEnd`` telemetry
event. See comments on the :c:type:`PageRetStruct` in ``poolamc.c``. These
page-based metrics are not as precise as actually counting the size of
objects, but they require much less intrusive code to implement, and
should be sufficient to assess whether AMC's page retention policies
and behaviour are acceptable.
Initial design
@ -586,11 +585,13 @@ Ramps
:mps:tag:`ramp` Ramps usefully implement the begin/end
:c:func:`mps_alloc_pattern_ramp()` interface.
:mps:tag:`gen.ramp` To implement ramping (request.dylan.170423), AMC uses a
:mps:tag:`gen.ramp` To implement ramping (request.dylan.170423_), AMC uses a
special "ramping mode", where promotions are redirected. One
generation is designated the "ramp generation" (``amc->rampGen`` in
the code).
.. _request.dylan.170423: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170423
:mps:tag:`gen.ramp.ordinary` Ordinarily, that is whilst not ramping, objects
are promoted into the ramp generation from younger generations and are
promoted out to older generations. The generation that the ramp

4
mps/manual/html/_sources/design/poolawl.txt
View file

@ -33,7 +33,9 @@ See req.dylan.fun.weak.
See meeting.dylan.1997-02-27(0) where many of the requirements for
this pool were first sorted out.
Must satisfy request.dylan.170123.
Must satisfy request.dylan.170123_.
.. _request.dylan.170123: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170123
:mps:tag:`req.obj-format` Only objects of a certain format need be
supported. This format is a subset of the Dylan Object Format. The

4
mps/manual/html/_sources/design/poolmvff.txt
View file

@ -134,8 +134,8 @@ object size (in both cases we align up).
:mps:tag:`design.seg-fail` If allocating a segment fails, we try again with
a segment size just large enough for the object we're allocating. This
is in response to `request.mps.170186`_.
is in response to request.mps.170186_.
.. _`request.mps.170186`: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/mps/170186/
.. _request.mps.170186: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/mps/170186

409
mps/manual/html/_sources/design/strategy.txt Normal file
View file

@ -0,0 +1,409 @@
.. _design-strategy:
MPS Strategy
============
.. mps:prefix:: design.mps.strategy
Introduction
------------
_`.intro` This is the design of collection strategy for the MPS.
_`.readership` MPS developers.
Overview
--------
_`.overview` The MPS uses "strategy" code to make three decisions:
- when to start a collection trace;
- what to condemn;
- how to schedule tracing work.
This document describes the current strategy, identifies some
weaknesses in it, and outlines some possible future development
directions.
Requirements
------------
[TODO: source some from req.dylan, or do an up-to-date requirements
analysis -- NB 2013-03-25]
Garbage collection is a trade-off between time and space: it consumes
some [CPU] time in order to save some [memory] space. Strategy shifts
the balance point. A better strategy will take less time to produce
more space. Examples of good strategy might include:
- choosing segments to condemn which contain high proportions of dead
objects;
- starting a trace when a large number of objects have just died;
- doing enough collection soon enough that the client program never
suffers low-memory problems;
- using otherwise-idle CPU resources for tracing.
Conversely, it would be bad strategy to do the reverse of each of
these (condemning live objects; tracing when there's very little
garbage; not collecting enough; tracing when the client program is
busy).
Abstracting from these notions, requirements on strategy would
relate to:
- Maximum pause time and other utilization metrics (for example,
bounded mutator utilization, minimum mutator utilization, total MPS
CPU usage);
- Collecting enough garbage (for example: overall heap size;
low-memory requirements).
- Allowing client control (for example, client recommendations for
collection timing or condemnation).
There are other possible strategy considerations which are so far
outside the scope of current strategy and MPS design that this
document disregards them. For example, either inferring or allowing
the client to specify preferred relative object locations ("this
object should be kept in the same cache line as that one"), to improve
cache locality.
Generations
-----------
The largest part of the current MPS strategy implementation is the
support for generational GC. Generations are only fully supported for
AMC (and AMCZ) pools. See under "Non-AMC Pools", below, for more
information.
Data Structures
...............
The fundamental structure of generational GC is the ``Chain``,
which describes a set of generations. A chain is created by client
code calling :c:func:`mps_chain_create()`, specifying the "size" and
"mortality" for each generation. When creating an AMC pool, the
client code must specify the chain which will control collections for
that pool. The same chain may be used for multiple pools.
Each generation in a chain has a ``GenDesc`` structure,
allocated in an array pointed to from the chain. Each AMC pool has a
set of ``PoolGen`` structures, one per generation. The PoolGens
for each generation point to the GenDesc and are linked together in a
ring on the GenDesc. These structures are (solely?) used to gather
information for strategy decisions.
The arena has a unique ``GenDesc`` structure, named
``topGen`` and described in comments as "the dynamic generation"
(although in fact it is the *least* dynamic generation). Each AMC
pool has one more PoolGen than there are GenDescs in the chain. The
extra PoolGen refers to this topGen.
AMC segments have a segment descriptor ``amcSegStruct`` which is
a :c:type:`GCSegStruct` with two additional fields. One field
``segTypeP`` is a pointer either to the per-generation per-pool
``amcGen`` structure (a subclass of ``PoolGen``), or to a
nailboard (which then points to an amcGen). The other field
``new`` is a boolean used for keeping track of memory usage for
strategy reasons (see below under 'Accounting'). The ``amcGen``
is used for statistics (``->segs``) and forwarding buffers
(``->forward``).
The AMC pool class only ever allocates a segment in order to fill a
buffer: either the buffer for a client Allocation Point, or a
forwarding buffer. In order to support generational collection, there
is a subclass ``amcBuf`` of ``SegBuf``, with a
``gen`` field (pointing to a ``amcGen``). So in
:c:func:`AMCBufferFill()` the generation of the new segment can be
determined.
When an AMC pool is created, these ``amcGen`` and
``amcBuf`` structures are all created, and the
``amcBuf->gen`` fields initialized so that the forwarding buffer
of each amcGen knows that it belongs to the next "older" amcGen (apart
from the "oldest" amcGen - that which refers to the topGen - whose
forwarding buffer belongs to itself).
When copying an object in :c:func:`AMCFix()`, the object's current
generation is determined (:c:func:`amcSegGen()`), and the object is
copied to that amcGen's forwarding buffer, using the buffer protocol.
Thus, objects are "promoted" up the chain of generations until they
end up in the topGen, which is shared between all chains and all
pools.
For statistics and reporting purposes, when :c:macro:`STATISTICS` is
on, each AMC pool has an array of :c:type:`PageRetStruct`s, one per
trace. This structure has many :c:type:`Count` fields, and is
intended to help to assess AMC page retention code. See job001811.
Zones
.....
All collections in the MPS start with condemnation of a complete
``ZoneSet``. Each generation in each chain has a zoneset
associated with it (``chain->gen[N].zones``); the condemned
zoneset is the union of some number of generation's zonesets. It is
condemned by code in the chain system calling
:c:func:`TraceCondemnZones()`. This is either for all chains
(:c:func:`ChainCondemnAll()` called for every chain from
:c:func:`traceCondemnAll()`) or for some number of generations in a
single chain (:c:func:`ChainCondemnAuto()` called from
:c:func:`TracePoll()`). Note that the condemnation is of every
automatic-pool segment in any zone in the zoneset. It is not limited
to the segments actually associated with the condemned generation(s).
An attempt is made to use distinct zonesets for different generations.
Whenever a segment is allocated (:c:func:`AMCBufferFill()`), a
``SegPref`` is created containing the generation number
(obtained from ``amcBuf->gen->pgen->nr``) and passed to
:c:func:`SegAlloc()`. The arena keeps a zoneset for each generation
number (up to ``VMArenaGenCount``, defined in
``arenavm.c`` to be ``MPS_WORD_WIDTH/2``), and a
``freeSet``. The zoneset for each generation number starts out
empty, and the ``freeSet`` starts out ``ZoneSetUNIV``.
When a segment is allocated with a ``SegPref`` with a generation
number, an attempt is made to allocate it in the corresponding zoneset
(:c:func:`pagesFindFreeInZones()`). If the zoneset is empty, an
attempt is made to allocate it in the ``freeSet`` zoneset.
After it is allocated, the zones it occupies are removed from the
``freeSet`` and (if there's a generation ``SegPref``)
added to the zoneset for that generation number.
Note that this zone placement code knows nothing of chains,
generations, pool classes, etc. It is based solely on the generation
*number*, so generations with the same number from different chains
share a zoneset preference for the purpose of placing newly allocated
segments. Combined with the fact that condemnation is per-zone, this
effectively means that generations in distinct chains are collected
together. One consequence of this is that we don't have a very fine
granularity of control over collection: a garbage collection of all
chains together is triggered by the most eager chain. There's no way
for a library or other small part of a client program to arrange
independent collection of a separate pool or chain.
When :c:func:`AMCBufferFill()` gets the allocated segment back, it
adds it to the zoneset associated with that generation in the pool's
controlling chain. Note that a chain's per-generation zonesets, which
represent the zones in which segments for that generation in that
chain have been placed, are quite distinct from the arena-wide
per-generation-number zonesets, which represent the zones in which
segments for that generation number in any chain have been placed.
The arena-wide per-generation-number zoneset
``vmArena->genZoneSet[N]`` is augmented in
:c:func:`vmAllocComm()`. The per-chain per-generation zoneset
``chain->gen[N].zones`` is augmented in
:c:func:`PoolGenUpdateZones()`. Neither kind of zoneset can ever
shrink.
Accounting
..........
- ``gen[N].mortality``
- Specified by the client.
- TODO: fill in how this is used.
- ``gen[N].capacity``
- Specified by the client.
- TODO: fill in how this is used.
- ``amcSeg->new``
- TODO: fill this in
- ``pgen->totalSize``:
- incremented by :c:func:`AMCBufferFill()`;
- decremented by :c:func:`amcReclaimNailed()` and :c:func:`AMCReclaim()`;
- added up by ``GenDescTotalSize(gen)``.
- ``pgen->newSize``:
- incremented by :c:func:`AMCBufferFill()` (*when not ramping*) and :c:func:`AMCRampEnd()`;
- decremented by :c:func:`AMCWhiten()`,
- added up by ``GenDescNewSize(gen)``.
- ``gen[N].proflow``:
- set to 1.0 by :c:func:`ChainCreate()`;
- ``arena->topGen.proflow`` set to 0.0 by ``LocusInit(arena)``;
- *The value of this field is never used*.
- ``pgen->newSizeAtCreate``:
- set by :c:func:`traceCopySizes()` (that is its purpose);
- output in the ``TraceStartPoolGen`` telemetry event.
Ramps
.....
The intended semantics of ramping are pretty simple. It allows the
client to advise us of periods of large short-lived allocation on a
particular AP. Stuff allocated using that AP during its "ramp" will
probably be dead when the ramp finishes. How the MPS makes use of this
advice is up to us, but for instance we might segregate those objects,
collect them less enthusiastically during the ramp and then more
enthusiastically soon after the ramp finishes. Ramps can nest.
A ramp is entered by calling::
mps_ap_alloc_pattern_begin(ap, mps_alloc_pattern_ramp())
or similar, and left in a similar way.
This is implemented on a per-pool basis, for AMC only (it's ignored by
the other automatic pools). PoolAMC throws away the identity of the AP
specified by the client. The implementation is intended to work by
changing the generational forwarding behaviour, so that there is a "ramp
generation" - one of the regular AMC generations - which forwards to
itself if collected during a ramp (instead of promoting to an older
generation). It also tweaks the strategy calculation code, in a way
with consequences I am documenting elsewhere.
Right now, the code sets this ramp generation to the last generation
specified in the pool's "chain": it ordinarily forwards to the
"after-ramp" generation, which is the "dynamic generation" (i.e. the
least dynamic generation, i.e. the arena-wide "top generation"). My
recollection, and some mentions in design/poolamc, suggests that the
ramp generation used to be chosen differently from this.
So far, it doesn't sound too ghastly, I guess, although the subversion
of the generational system seems a little daft. Read on....
An AMC pool has a ``rampMode`` (which is really a state of a state
machine), taking one of five values: OUTSIDE, BEGIN, RAMPING, FINISH,
and COLLECTING (actually the enum values are called RampX for these
X). We initialize in OUTSIDE. The pool also has a ``rampCount``,
which is the ramp nesting depth and is used to allow us to ignore ramp
transitions other than the outermost. According to design/poolamc,
there's an invariant (in BEGIN or RAMPING, ``rampCount > 0``; in
COLLECTING or OUTSIDE, ``rampCount == 0``), but this isn't checked in
:c:func:`AMCCheck()` and in fact is false for COLLECTING (see below).
There is a small set of events causing state machine transitions:
- entering an outermost ramp;
- leaving an outermost ramp;
- condemning any segment of a ramp generation (detected in AMCWhiten);
- reclaiming any AMC segment.
Here's pseudo-code for all the transition events:
Entering an outermost ramp:
if not FINISH, go to BEGIN.
Leaving an outermost ramp:
if RAMPING, go to FINISH. Otherwise, go to OUTSIDE.
Condemning a ramp generation segment:
If BEGIN, go to RAMPING and make the ramp generation forward
to itself (detach the forwarding buffer and reset its generation).
If FINISH, go to COLLECTING and make the ramp generation
forward to the after-ramp generation.
Reclaiming any AMC segment:
If COLLECTING:
if ``rampCount > 0``, go to BEGIN. Otherwise go to OUTSIDE.
Now, some deductions:
1. When OUTSIDE, the count is always zero, because (a) it starts that
way, and the only ways to go OUTSIDE are (b) by leaving an outermost
ramp (count goes to zero) or (c) by reclaiming when the count is zero.
2. When BEGIN, the count is never zero (consider the transitions to
BEGIN and the transition to zero).
3. When RAMPING, the count is never zero (again consider transitions to
RAMPING and the transition to zero).
4. When FINISH, the count can be anything (the transition to FINISH has
zero count, but the Enter transition when FINISH can change that and
then it can increment to any value).
5. When COLLECTING, the count can be anything (from the previous fact,
and the transition to COLLECTING).
6. *This is a bug!!* The ramp generation is not always reset (to forward
to the after-ramp generation). If we get into FINISH and then see
another ramp before the next condemnation of the ramp generation, we
will Enter followed by Leave. The Enter will keep us in FINISH, and
the Leave will take us back to OUTSIDE, skipping the transition to the
COLLECTING state which is what resets the ramp generation forwarding
buffer. [TODO: check whether I made an issue and/or fixed it; NB 2013-06-04]
The simplest change to fix this is to change the behaviour of the Leave
transition, which should only take us OUTSIDE if we are in BEGIN or
COLLECTING. We should also update design/poolamc to tell the truth, and
check the invariants, which will be these:
OUTSIDE => zero
BEGIN => non-zero
RAMPING => non-zero
A cleverer change might radically rearrange the state machine
(e.g. reduce the number of states to three) but that would require
closer design thought and should probably be postponed until we have a
clearer overall strategy plan.
While I'm writing pseudo-code versions of ramp-related code, I should
mention this other snippet, which is the only other code relating to
ramping (these notes are useful when thinking about the broader strategy
code):
In :c:func:`AMCBufferFill()`, if we're RAMPING, and filling the forwarding
buffer of the ramp generation, and the ramp generation is the
forwarding buffer's generation, set ``amcSeg->new`` to FALSE. Otherwise,
add the segment size to ``poolGen.newSize``.
And since I've now mentioned the ``amcSeg->new`` flag, here are the only
other uses of that:
- it initializes as TRUE.
- When leaving an outermost ramp, go through all the segments in the
pool. Any non-white segment in the rampGen with new set to FALSE has
its size added to ``poolGen->newSize`` and gets new set to TRUE.
- in :c:func:`AMCWhiten()`, if new is TRUE, the segment size is deducted
from ``poolGen.newSize`` and new is set to FALSE.
Non-AMC Pools
.............
The implementations of AMS, AWL, and LO pool classes are all aware of
generations (this is necessary because all tracing is driven by the
generational data structures described above), but do not make use of
them. For LO and AWL, when a pool is created, a chain with a single
generation is also created, with size and mortality parameters
hard-wired into the pool-creation function (LOInit, AWLInit). For
AMS, a chain is passed as a pool creation parameter into
:c:func:`mps_pool_create()`, but this chain must also have only a
single generation (otherwise ``ResPARAM`` is returned).
Note that these chains are separate from any chain used by an AMC pool
(except in the trivial case when a single-generation chain is used for
both AMC and AMS). Note also that these pools do not use or point to
the ``arena->topGen``, which applies only to AMC.
Non-AMC pools have no support for ramps.
Starting a Trace
................
TODO: Why do we start a trace? How do we choose what to condemn?
Trace Progress
..............
TODO: When do we do some tracing work? How much tracing work do we do?

15
mps/manual/html/_sources/design/trace.txt
View file

@ -31,16 +31,20 @@ concurrent traces. This limitation is expressed in the symbol
.. note::
:c:macro:`TRACE_MAX` is currently set to 1, see request.mps.160020
:c:macro:`TRACE_MAX` is currently set to 1, see request.mps.160020_
"Multiple traces would not work". David Jones, 1998-06-15.
.. _request.mps.160020: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/mps/160020
:mps:tag:`rate` See `mail.nickb.1997-07-31.14-37 </project/mps/mail/1997/07/31/14-37/0.txt>`_.
.. note::
Now revised? See request.epcore.160062 and
Now revised? See request.epcore.160062_ and
change.epcore.minnow.160062. David Jones, 1998-06-15.
.. _request.epcore.160062: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160062
:mps:tag:`exact.legal` Exact references should either point outside the
arena (to non-managed address space) or to a tract allocated to a
pool. Exact references that are to addresses which the arena has
@ -70,10 +74,11 @@ Analysis
referenced object has failed (due to lack of memory, for example), by
backing off to treating a reference as ambiguous. Assuming that fixing
an ambiguous reference doesn't allocate memory (which is no longer
true for AMC for example). See request.dylan.170560 for a slightly
true for AMC for example). See request.dylan.170560_ for a slightly
more sophisticated way to proceed when you can no longer allocate
memory for copying.
.. _request.dylan.170560: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170560
Ideas
-----
@ -126,9 +131,11 @@ the Dylan compiler.
:mps:tag:`reclaim` Because the reclaim phase of the trace (implemented by
:c:func:`TraceReclaim()`) examines every segment it is fairly time intensive.
rit's profiles presented in request.dylan.170551 show a gap between
rit's profiles presented in request.dylan.170551_ show a gap between
the two varieties variety.hi and variety.wi.
.. _request.dylan.170551: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170551
:mps:tag:`reclaim.noaver` Converting :c:func:`AVER()` statements in the loops of
:c:func:`TraceReclaim()`, :c:func:`PoolReclaim()`, :c:func:`AMCReclaim()` (:c:func:`LOReclaim()`?
:c:func:`AWLReclaim()`?) will result in a noticeable speed improvement.

3
mps/manual/html/_sources/design/version-library.txt
View file

@ -29,9 +29,10 @@ Source
------
:mps:tag:`source` Various requirements demand such a mechanism. See
request.epcore.160021: There is no way to tell which version and
request.epcore.160021_: There is no way to tell which version and
release of the MM one is using.
.. _request.epcore.160021: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160021
Overview
--------

8
mps/manual/html/_sources/design/vm.txt
View file

@ -109,11 +109,15 @@ they ask for too much, :c:func:`mps_arena_create()` (and hence
:mps:tag:`testing.larger` It must be possible to allocate in a large space;
sometimes commiting will fail, because there's not enough space to
replace the "reserve" mapping. See request.epcore.160201 for details.
replace the "reserve" mapping. See request.epcore.160201_ for details.
.. _request.epcore.160201: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160201
:mps:tag:`testing.lots` It must be possible to have lots of mappings. The OS
must either combine adjacent mappings or have lots of space in the
kernel tables. See request.epcore.160117 for ideas on how to test
kernel tables. See request.epcore.160117_ for ideas on how to test
this.
.. _request.epcore.160117: https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160117

7
mps/manual/html/_sources/glossary/i.txt
View file

@ -80,6 +80,13 @@ Memory Management Glossary: I
.. seealso:: :term:`stack frame`, :term:`activation frame`.
.. mps:specific::
In-band headers are supported by some :term:`pool classes`
and the size of the header is specified by passing the
:c:macro:`MPS_KEY_FMT_HEADER_SIZE` :term:`keyword
argument` to :c:func:`mps_fmt_create_k`.
in parameter
A function parameter that supplies data from the caller to the

23
mps/manual/html/_sources/guide/advanced.txt
View file

@ -691,23 +691,16 @@ The :term:`skip method` is straightforward::
length * sizeof(buckets->bucket[0]));
}
as is the object format, since AWL only calls the scan and skip
methods::
struct mps_fmt_A_s buckets_fmt_s = {
ALIGNMENT,
buckets_scan,
buckets_skip,
NULL, /* Obsolete copy method */
NULL, /* fwd method not used by AWL */
NULL, /* isfwd method not used by AWL */
NULL /* pad method not used by AWL */
};
Finally, we can create the buckets pool and its allocation points::
Now we can create the object format, the pool and the allocation
points::
/* Create the buckets format. */
res = mps_fmt_create_A(&buckets_fmt, arena, &buckets_fmt_s);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, ALIGNMENT);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, buckets_scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, buckets_skip);
res = mps_fmt_create_k(&buckets_fmt, arena, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create buckets format");
/* Create an Automatic Weak Linked (AWL) pool to manage the hash table

45
mps/manual/html/_sources/guide/lang.txt
View file

@ -256,32 +256,27 @@ you need to tell it how to perform various operations on an object
so on). You do this by creating an :term:`object format`. Here's the
code for creating the object format for the toy Scheme interpreter::
struct mps_fmt_A_s obj_fmt_s = {
ALIGNMENT,
obj_scan,
obj_skip,
NULL,
obj_fwd,
obj_isfwd,
obj_pad,
};
mps_fmt_t obj_fmt;
res = mps_fmt_create_A(&obj_fmt, arena, &obj_fmt_s);
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, ALIGNMENT);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, obj_scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, obj_skip);
MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, obj_fwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, obj_isfwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, obj_pad);
MPS_ARGS_DONE(args);
res = mps_fmt_create_k(&obj_fmt, arena, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create obj format");
The structure :c:type:`mps_fmt_A_s` is the simplest of several object
format variants that are appropriate for moving pools like AMC.
The first element of the structure is the :term:`alignment` of objects
belonging to this format. Determining the alignment is hard to do
portably, because it depends on the target architecture and on the way
the compiler lays out its structures in memory. Here are some things
you might try:
The argument for the keyword :c:macro:`MPS_KEY_FMT_ALIGN` is the
:term:`alignment` of objects belonging to this format. Determining the
alignment is hard to do portably, because it depends on the target
architecture and on the way the compiler lays out its structures in
memory. Here are some things you might try:
1. Some modern compilers support the ``alignof`` operator::
#define ALIGNMENT alignof(obj_s)
#define ALIGNMENT alignof(obj_s)
2. On older compilers you may be able to use this trick::
@ -301,10 +296,9 @@ you might try:
#define ALIGNMENT sizeof(mps_word_t)
The other elements of the structure are the :term:`format methods`,
which are described in the following sections. (The ``NULL`` in the
structure is a placeholder for the :term:`copy method`, which is now
obsolete.)
The other keyword arguments specify the :term:`format methods`
required by the AMC pool class, which are described in the following
sections.
.. topics::
@ -1227,6 +1221,7 @@ on.
Here's the tear-down code from the toy Scheme interpreter::
mps_arena_park(arena);
mps_ap_destroy(obj_ap);
mps_pool_destroy(obj_pool);
mps_chain_destroy(obj_chain);

9
mps/manual/html/_sources/pool/amc.txt
View file

@ -74,7 +74,7 @@ AMC properties
* Blocks are :term:`scanned <scan>`.
* Blocks may only be referenced by :term:`base pointers` (unless they
belong to an object format of variant auto-header).
have :term:`in-band headers`).
* Blocks may be protected by :term:`barriers (1)`.
@ -82,7 +82,12 @@ AMC properties
* Blocks may be registered for :term:`finalization`.
* Blocks must belong to an :term:`object format`.
* Blocks must belong to an :term:`object format` which provides
:term:`scan <scan method>`, :term:`skip <skip method>`,
:term:`forward <forward method>`, :term:`is-forwarded <is-forwarded
method>`, and :term:`padding <padding method>` methods.
* Blocks may have :term:`in-band headers`.
.. index::

12
mps/manual/html/_sources/pool/ams.txt
View file

@ -73,18 +73,18 @@ AMS properties
* Blocks are :term:`scanned <scan>`.
* Blocks may only be referenced by :term:`base pointers` (unless they
belong to an object format of variant auto-header).
have :term:`in-band headers`).
* Blocks are not protected by :term:`barriers (1)`.
* Blocks do not :term:`move <moving garbage collector>`. A consequence
of this is that the pool's :term:`object format` need not provide a
:term:`forward method`, an :term:`is-forwarded method` or a
:term:`padding method`.
* Blocks do not :term:`move <moving garbage collector>`.
* Blocks may be registered for :term:`finalization`.
* Blocks must belong to an :term:`object format`.
* Blocks must belong to an :term:`object format` which provides
:term:`scan <scan method>` and :term:`skip <skip method>` methods.
* Blocks may have :term:`in-band headers`.
.. index::

12
mps/manual/html/_sources/pool/awl.txt
View file

@ -95,18 +95,18 @@ AWL properties
* Blocks are :term:`scanned <scan>`.
* Blocks may only be referenced by :term:`base pointers` (unless they
belong to an object format of variant auto-header).
have :term:`in-band headers`).
* Blocks may be protected by :term:`barriers (1)`.
* Blocks do not :term:`move <moving garbage collector>`. A consequence
of this is that the pool's :term:`object format` need not provide a
:term:`forward method`, an :term:`is-forwarded method` or a
:term:`padding method`.
* Blocks do not :term:`move <moving garbage collector>`.
* Blocks may be registered for :term:`finalization`.
* Blocks must belong to an :term:`object format`.
* Blocks must belong to an :term:`object format` which provides
:term:`scan <scan method>` and :term:`skip <skip method>` methods.
* Blocks may have :term:`in-band headers`.
.. index::

8
mps/manual/html/_sources/pool/intro.txt
View file

@ -113,7 +113,7 @@ Blocks may be protected by barriers? yes no yes yes yes
Blocks may move? yes yes no no no no no no no no
Blocks may be finalized? yes yes yes yes yes no no no no no
Blocks must be formatted? [11]_ yes yes yes yes yes no no no no yes
Blocks may belong to format auto-header? yes yes yes yes yes --- --- --- --- no
Blocks may use :term:`in-band headers`? yes yes yes yes yes --- --- --- --- no
============================================= ===== ===== ===== ===== ===== ===== ===== ===== ===== =====
.. note::
@ -174,9 +174,9 @@ Blocks may belong to format auto-header? yes yes yes yes yes
location within the block is considered to be a reference
to the block. It "supports base pointers only" if only a
pointer to the base of the block (or, if the block belongs
to an object format of variant auto-header, a pointer just
past the end of the header) is considered to be a reference
to the block.
to an object format with :term:`in-band headers`, a pointer
just past the end of the header) is considered to be a
reference to the block.
.. index::

12
mps/manual/html/_sources/pool/lo.txt
View file

@ -76,18 +76,18 @@ LO properties
method`.
* Blocks may only be referenced by :term:`base pointers` (unless they
belong to an object format of variant auto-header).
have :term:`in-band headers`).
* Blocks are not protected by :term:`barriers (1)`.
* Blocks do not :term:`move <moving garbage collector>`. A consequence
of this is that the pool's :term:`object format` need not provide a
:term:`forward method` or an :term:`is-forwarded method`. (It also
does not need a :term:`padding method`.)
* Blocks do not :term:`move <moving garbage collector>`.
* Blocks may be registered for :term:`finalization`.
* Blocks must belong to an :term:`object format`.
* Blocks must belong to an :term:`object format` which provides
:term:`scan <scan method>` and :term:`skip <skip method>` methods.
* Blocks may have :term:`in-band headers`.
.. index::

6
mps/manual/html/_sources/pool/mfs.txt
View file

@ -81,7 +81,7 @@ MFS interface
:term:`pool`.
When creating an MFS pool, :c:func:`mps_pool_create_k` requires
one :term:`keyword arguments`:
one :term:`keyword argument`:
* :c:macro:`MPS_KEY_MFS_UNIT_SIZE` (type :c:type:`size_t`) is the
:term:`size` of blocks that will be allocated from this pool, in
@ -99,8 +99,8 @@ MFS interface
For example::
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(ARGS, MPS_KEY_MFS_UNIT_SIZE, 1024);
MPS_ARGS_ADD(ARGS, MPS_KEY_EXTEND_BY, 1024 * 1024);
MPS_ARGS_ADD(args, MPS_KEY_MFS_UNIT_SIZE, 1024);
MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, 1024 * 1024);
MPS_ARGS_DONE(args);
res = mps_pool_create_k(&pool, arena, mps_class_mfs(), args);
} MPS_ARGS_END(args);

6
mps/manual/html/_sources/pool/mv.txt
View file

@ -93,9 +93,9 @@ MV interface
For example::
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(ARGS, MPS_KEY_MEAN_SIZE, 32);
MPS_ARGS_ADD(ARGS, MPS_KEY_MAX_SIZE, 1024);
MPS_ARGS_ADD(ARGS, MPS_KEY_EXTEND_BY, 1024 * 1024);
MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, 32);
MPS_ARGS_ADD(args, MPS_KEY_MAX_SIZE, 1024);
MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, 1024 * 1024);
MPS_ARGS_DONE(args);
res = mps_pool_create_k(&pool, arena, mps_class_mfs(), args);
} MPS_ARGS_END(args);

12
mps/manual/html/_sources/pool/mvff.txt
View file

@ -164,12 +164,12 @@ MVFF interface
For example::
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(ARGS, MPS_KEY_EXTEND_BY, 1024 * 1024);
MPS_ARGS_ADD(ARGS, MPS_KEY_MEAN_SIZE, 32);
MPS_ARGS_ADD(ARGS, MPS_KEY_ALIGN, 8);
MPS_ARGS_ADD(ARGS, MPS_KEY_MVFF_ARENA_HIGH, 1);
MPS_ARGS_ADD(ARGS, MPS_KEY_MVFF_SLOT_HIGH, 1);
MPS_ARGS_ADD(ARGS, MPS_KEY_MVFF_FIRST_FIT, 0);
MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, 1024 * 1024);
MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, 32);
MPS_ARGS_ADD(args, MPS_KEY_ALIGN, 8);
MPS_ARGS_ADD(args, MPS_KEY_MVFF_ARENA_HIGH, 1);
MPS_ARGS_ADD(args, MPS_KEY_MVFF_SLOT_HIGH, 1);
MPS_ARGS_ADD(args, MPS_KEY_MVFF_FIRST_FIT, 0);
MPS_ARGS_DONE(args);
res = mps_pool_create_k(&pool, arena, mps_class_mvff(), args);
} MPS_ARGS_END(args);

10
mps/manual/html/_sources/pool/mvt.txt
View file

@ -182,11 +182,11 @@ MVT interface
For example::
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(ARGS, MPS_KEY_MIN_SIZE, 4);
MPS_ARGS_ADD(ARGS, MPS_KEY_MEAN_SIZE, 32);
MPS_ARGS_ADD(ARGS, MPS_KEY_MAX_SIZE, 1024);
MPS_ARGS_ADD(ARGS, MPS_KEY_MVT_RESERVE_DEPTH, 256);
MPS_ARGS_ADD(ARGS, MPS_KEY_MVT_FRAG_LIMIT, 0.5);
MPS_ARGS_ADD(args, MPS_KEY_MIN_SIZE, 4);
MPS_ARGS_ADD(args, MPS_KEY_MEAN_SIZE, 32);
MPS_ARGS_ADD(args, MPS_KEY_MAX_SIZE, 1024);
MPS_ARGS_ADD(args, MPS_KEY_MVT_RESERVE_DEPTH, 256);
MPS_ARGS_ADD(args, MPS_KEY_MVT_FRAG_LIMIT, 0.5);
MPS_ARGS_DONE(args);
res = mps_pool_create_k(&pool, arena, mps_class_mvt(), args);
} MPS_ARGS_END(args);

10
mps/manual/html/_sources/pool/snc.txt
View file

@ -70,13 +70,13 @@ SNC properties
* Blocks do not :term:`move <moving garbage collector>`.
* Blocks may not be registered for :term:`finalization`. A consequence
of this is that the pool's :term:`object format` need not provide a
:term:`forward method` or an :term:`is-forwarded method`.
* Blocks may not be registered for :term:`finalization`.
* Blocks must belong to an :term:`object format`, but this may not be
a format of variant auto-header.
* Blocks must belong to an :term:`object format` which provides
:term:`scan <scan method>`, :term:`skip <skip method>`, and
:term:`padding <padding method>` methods.
* Blocks must not have :term:`in-band headers`.
.. index::

14
mps/manual/html/_sources/topic/finalization.txt
View file

@ -178,6 +178,20 @@ Cautions
deprecated. See Appendix A of :ref:`Boehm (2002) <BOEHM02>`
for a discussion of this problem.
.. note::
You can safely destroy pools containing objects registered for
finalization if you follow the "safe tear-down" procedure
described under :c:func:`mps_pool_destroy`, but the objects do
not get finalized.
The only reliable way to ensure that all finalizable object
gets finalized is to maintain a table of :term:`weak
references (1)` to all such objects. The weak references don't
prevent the objects from being finalized, but you can iterate
over the list at an appropriate point and finalize any
remaining objects yourself.
4. Not all :term:`pool classes` support finalization. In general, only
pools that manage objects whose liveness is determined by garbage
collection do so. See the :ref:`pool`.

467
mps/manual/html/_sources/topic/format.txt
View file

@ -37,249 +37,91 @@ has moved with a :term:`forwarding object`).
Not every :term:`pool class` supports :term:`formatted objects`.
.. index::
single: object format; interface
Interface
---------
.. c:type:: mps_fmt_t
The type of an :term:`object format`.
.. index::
single: object format; creating
.. c:function:: void mps_fmt_create_k(mps_fmt_t *mps_fmt_o, mps_arena_t arena, mps_arg_s args[])
Creating an object format
-------------------------
Different :term:`pool classes` use different sets of format methods
and values (for example, a non-moving pool does not need forwarding
objects, so its object formats do not need to contain a forward
method). To accommodate this variance, it is possible to construct
object formats from different collections of format methods and
values. Such a collection is called a *format variant*.
There are three supported format variants. All are suitable for
copying and moving pools.
* Variant A (:c:type:`mps_fmt_A_s`): for objects without
:term:`headers <in-band header>`.
* Variant B (:c:type:`mps_fmt_B_s`): as variant A, but with the
addition of a class method.
* Variant auto-header (:c:type:`mps_fmt_auto_header_s`): for objects
with :term:`headers <in-band header>`.
The client program creates an object format by construct a format
variant structure and then calling the appropriate ``mps_fmt_create_``
function for the variant. The variant structure can then be disposed
of.
For example::
struct mps_fmt_A_s obj_fmt_s = {
ALIGNMENT,
obj_scan,
obj_skip,
NULL, /* Obsolete copy method */
obj_fwd,
obj_isfwd,
obj_pad
};
mps_pool_t obj_pool;
mps_fmt_t obj_fmt;
mps_res_t res;
res = mps_fmt_create_A(&obj_fmt, arena, &obj_fmt_s);
if (res != MPS_RES_OK) error("Couldn't create obj format");
/* obj_fmt created successfully */
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FORMAT, obj_fmt);
MPS_ARGS_DONE(args);
res = mps_pool_create_k(&obj_pool, arena, pool_class, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create obj pool");
.. c:type:: mps_fmt_A_s
The type of the structure used to create an :term:`object format`
of variant A. ::
typedef struct mps_fmt_A_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_skip_t skip;
mps_fmt_copy_t copy;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
} mps_fmt_A_s;
Broadly speaking, object formats of variant A are suitable for use
in :term:`copying <copying garbage collection>` or :term:`moving
<moving garbage collector>` :term:`pools`.
``align`` is an integer value specifying the alignment of objects
allocated with this format. It should be large enough to satisfy
the alignment requirements of any field in the objects, and it
must not be larger than the pool alignment.
``scan`` is a :term:`scan method` that identifies references
within objects belonging to this format. See
:c:type:`mps_fmt_scan_t`.
``skip`` is a :term:`skip method` that skips over objects
belonging to this format. See :c:type:`mps_fmt_skip_t`.
``copy`` is not used. (In older versions of the MPS it was a
:term:`copy method` that copied objects belonging to this
format.)
``fwd`` is a :term:`forward method` that stores relocation
information for an object belonging to this format that has moved.
See :c:type:`mps_fmt_fwd_t`.
``isfwd`` is a :term:`is-forwarded method` that determines if an
object belonging to this format has been moved. See
:c:type:`mps_fmt_isfwd_t`.
``pad`` is a :term:`padding method` that creates :term:`padding
objects` belonging to this format. See :c:type:`mps_fmt_pad_t`.
.. c:function:: mps_res_t mps_fmt_create_A(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_A_s *fmt_A)
Create an :term:`object format` of variant A.
Create an :term:`object format`.
``fmt_o`` points to a location that will hold the address of the new
object format.
``arena`` is the arena in which to create the format.
``fmt_A`` points to a description of an object format of variant A.
``args`` are :term:`keyword arguments` describing the format. Each
:term:`pool class` requires a particular subset of these keyword
arguments: see the documentation for that pool class.
Returns :c:macro:`MPS_RES_OK` if successful. The MPS may exhaust
some resource in the course of :c:func:`mps_fmt_create_A` and will
return an appropriate :term:`result code` if so.
* :c:macro:`MPS_KEY_FMT_ALIGN` (type :c:type:`mps_align_t`,
default :c:macro:`MPS_PF_ALIGN`) is an integer value specifying
the alignment of objects allocated with this format. It should
be large enough to satisfy the alignment requirements of any
field in the objects, and it must not be larger than the pool
alignment.
After this function returns, the object format description pointed
to be ``fmt_A`` is no longer needed and may be discarded. The object
format pointed to by ``fmt_o`` persists until it is destroyed by
calling :c:func:`mps_fmt_destroy`.
* :c:macro:`MPS_KEY_FMT_HEADER_SIZE` (type :c:type:`mps_size_t`,
default 0) is an integer value specifying the header size for
objects with :term:`in-band headers`. See
:ref:`topic-format-headers` below.
* :c:macro:`MPS_KEY_FMT_SCAN` (type :c:type:`mps_fmt_scan_t`) is a
:term:`scan method` that identifies references within objects
belonging to this format. See :c:type:`mps_fmt_scan_t`.
.. c:type:: mps_fmt_B_s
* :c:macro:`MPS_KEY_FMT_SKIP` (type :c:type:`mps_fmt_skip_t`) is a
:term:`skip method` that skips over objects belonging to this
format. See :c:type:`mps_fmt_skip_t`.
The type of the structure used to create an :term:`object format`
of variant B. ::
* :c:macro:`MPS_KEY_FMT_FWD` (type :c:type:`mps_fmt_fwd_t`) is a
:term:`forward method` that stores relocation information for an
object belonging to this format that has moved. See
:c:type:`mps_fmt_fwd_t`.
typedef struct mps_fmt_B_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_skip_t skip;
mps_fmt_copy_t copy;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
mps_fmt_class_t mps_class;
} mps_fmt_B_s;
* :c:macro:`MPS_KEY_FMT_ISFWD` (type :c:type:`mps_fmt_isfwd_t`) is
a :term:`is-forwarded method` that determines if an object
belonging to this format has been moved. See
:c:type:`mps_fmt_isfwd_t`.
Variant B is the same as variant A except for the addition of the
``mps_class`` method. See :c:type:`mps_fmt_A_s`.
* :c:macro:`MPS_KEY_FMT_PAD` (type :c:type:`mps_fmt_pad_t`) is a
:term:`padding method` that creates :term:`padding objects`
belonging to this format. See :c:type:`mps_fmt_pad_t`.
* :c:macro:`MPS_KEY_FMT_CLASS` (type :c:type:`mps_fmt_class_t`) is
a method that returns an address that is related to the class or
type of the object, for inclusion in the :term:`telemetry
stream` for some events relating to the object. See
:c:type:`mps_fmt_class_t`.
.. c:function:: mps_res_t mps_fmt_create_B(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_B_s *fmt_B)
:c:func:`mps_fmt_create_k` returns :c:macro:`MPS_RES_OK` if
successful. The MPS may exhaust some resource in the course of
:c:func:`mps_fmt_create_k` and will return an appropriate
:term:`result code` if so.
Create an :term:`object format` of variant B.
The object format pointed to by ``fmt_o`` persists until it is
destroyed by calling :c:func:`mps_fmt_destroy`.
``fmt_o`` points to a location that will hold the address of the new
object format.
For example::
``arena`` is the arena in which to create the format.
``fmt_B`` points to a description of an object format of variant B.
Returns :c:macro:`MPS_RES_OK` if successful. The MPS may exhaust
some resource in the course of :c:func:`mps_fmt_create_B` and will
return an appropriate :term:`result code` if so.
.. c:type:: mps_fmt_auto_header_s
The type of the structure used to create an :term:`object format`
of variant auto-header. ::
typedef struct mps_fmt_auto_header_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_skip_t skip;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
size_t mps_headerSize;
} mps_fmt_auto_header_s;
Variant auto-header is the same as variant A except for the
removal of the unused ``copy`` method, and the addition of the
``mps_headerSize`` field. See :c:type:`mps_fmt_A_s`.
Broadly speaking, the object formats of this variant are suitable
for use in :term:`automatic memory management` for objects with
:term:`headers <in-band header>` (hence the name). More precisely,
this variant is intended for formats where the :term:`client
program's <client program>` pointers point some distance into the
memory :term:`block` containing the object. This typically happens
when the objects have a common header used for memory management
or class system purposes, but this situation also arises when the
low bits of a pointer are used for a tag. The MPS does not care
what the reason is, only about the offset of the pointer in
relation to the memory block.
``mps_headerSize`` is the size of the header, that is, the offset of
a client pointer from the base of the memory block.
.. note::
Format methods (other than the :term:`padding method`) for
formats of this variant will receive *client pointers* (that
is, pointers past the header) but all other MPS functions
expect to receive and return *base pointers* (that is,
pointers to the base of the block where the header is stored).
In particular, :c:func:`mps_reserve` and :c:func:`mps_alloc`
always hand out base pointers, and :c:func:`mps_free` expects
to receive one.
.. note::
For technical reasons, formatted objects must be longer than
the header. In other words, objects consisting of only a
header are not supported.
.. note::
Even if the header size is larger than or equal to
:term:`alignment`, the :term:`padding method` must still be
able to create :term:`padding objects` down
to the alignment size.
.. c:function:: mps_res_t mps_fmt_create_auto_header(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_auto_header_s *fmt_ah)
Create an :term:`object format` of variant auto-header.
``fmt_o`` points to a location that will hold the address of the new
object format.
``arena`` is the arena in which to create the format.
``fmt_ah`` points to a description of an object format of variant
auto-header.
Returns :c:macro:`MPS_RES_OK` if successful. The MPS may exhaust
some resource in the course of
:c:func:`mps_fmt_create_auto_header` and will return an
appropriate :term:`result code` if so.
MPS_ARGS_BEGIN(args) {
MPS_ARGS_ADD(args, MPS_KEY_FMT_ALIGN, ALIGNMENT);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SCAN, obj_scan);
MPS_ARGS_ADD(args, MPS_KEY_FMT_SKIP, obj_skip);
MPS_ARGS_ADD(args, MPS_KEY_FMT_FWD, obj_fwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_ISFWD, obj_isfwd);
MPS_ARGS_ADD(args, MPS_KEY_FMT_PAD, obj_pad);
MPS_ARGS_DONE(args);
res = mps_fmt_create_k(&obj_fmt, arena, args);
} MPS_ARGS_END(args);
if (res != MPS_RES_OK) error("Couldn't create obj format");
.. c:function:: void mps_fmt_destroy(mps_fmt_t fmt)
@ -292,6 +134,51 @@ For example::
:term:`pool` using the format. The pool must be destroyed first.
.. index::
pair: object format; in-band headers
pair: object format; headers
.. _topic-format-headers:
In-band headers
---------------
There are use cases in which it is convenient for the :term:`client
program's <client program>` pointers to point some distance into the
memory :term:`block` containing the object. This typically happens
when the objects have a common :term:`in-band header` used for memory
management or class system purposes, but this situation also arises
when the low bits of a pointer are used for a tag. The MPS does not
care what the reason is, only about the offset of the pointer in
relation to the memory block.
If you have one of these use cases, you should pass the
:c:macro:`MPS_KEY_FMT_HEADER_SIZE` :term:`keyword argument` to
:c:func:`mps_fmt_create_k`, specifying the size of the header: that
is, the offset of a client pointer from the base of the memory block.
There are some cautions to be observed when using in-band headers:
1. The format methods (other than the :term:`padding method`) receive
*client pointers* (that is, pointers past the header) but all other
MPS functions expect to receive and return *base pointers* (that
is, pointers to the base of the block where the header is stored).
In particular, :c:func:`mps_reserve` and :c:func:`mps_alloc` always
hand out base pointers, and :c:func:`mps_free` expects to receive
one.
2. Formatted objects must be longer than the header. In other words,
objects consisting of only a header are not supported.
3. Even if the header size is larger than or equal to
:term:`alignment`, the :term:`padding method` must still be able to
create :term:`padding objects` down to the alignment size.
4. Not all :term:`pool classes` support objects with in-band headers.
See the documentation for the pool class.
.. index::
pair: object format; cautions
@ -454,7 +341,8 @@ Format methods
.. note::
The padding method always receives a base pointer, even if the
object format belongs to variant auto-header.
object format has a non-zero
:c:macro:`MPS_KEY_FMT_HEADER_SIZE`.
.. c:type:: mps_res_t (*mps_fmt_scan_t)(mps_ss_t ss, mps_addr_t base, mps_addr_t limit)
@ -502,9 +390,8 @@ Format methods
Returns the address of the "next object". In an object format
without headers (for example, a format of variant A), this is the
address just past the end of this object. In an object format with
headers (for example, a format of variant auto-header), it's the
address just past where the header of next object would be, if
there were one.
:term:`in-band headers`, it's the address just past where the
header of next object would be, if there were one.
.. note::
@ -628,3 +515,137 @@ Object format introspection
.. seealso::
:ref:`topic-arena`.
Obsolete interface
------------------
.. deprecated:: starting with version 1.112.
Use :c:func:`mps_ap_create_k` instead: the :term:`keyword
arguments` interface is more flexible and easier to understand.
Formerly the only way to create object formats was to describe the
format in the form of a *format variant structure*.
There are four format variants.
* Variant A (:c:type:`mps_fmt_A_s`): for objects without
:term:`headers <in-band header>`.
* Variant B (:c:type:`mps_fmt_B_s`): as variant A, but with the
addition of a class method.
* Variant auto-header (:c:type:`mps_fmt_auto_header_s`): for objects
with :term:`in-band headers`.
* Variant fixed (:c:type:`mps_fmt_fixed_s`): for fixed-size objects.
The client program creates an object format by construct a format
variant structure and then calling the appropriate ``mps_fmt_create_``
function for the variant. The variant structure can then be disposed
of.
.. c:type:: mps_fmt_A_s
The type of the structure used to create an :term:`object format`
of variant A. ::
typedef struct mps_fmt_A_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_skip_t skip;
mps_fmt_copy_t copy;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
} mps_fmt_A_s;
The fields of this structure correspond to the keyword arguments
to :c:func:`mps_fmt_create_k`, except for ``copy``, which is not
used. In older versions of the MPS this was a :term:`copy method`
that copied objects belonging to this format.
.. c:function:: mps_res_t mps_fmt_create_A(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_A_s *fmt_A)
Create an :term:`object format` based on a description of an
object format of variant A.
.. c:type:: mps_fmt_B_s
The type of the structure used to create an :term:`object format`
of variant B. ::
typedef struct mps_fmt_B_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_skip_t skip;
mps_fmt_copy_t copy;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
mps_fmt_class_t mps_class;
} mps_fmt_B_s;
Variant B is the same as variant A except for the addition of the
``mps_class`` method. See :c:type:`mps_fmt_A_s`.
.. c:function:: mps_res_t mps_fmt_create_B(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_B_s *fmt_B)
Create an :term:`object format` based on a description of an
object format of variant B.
.. c:type:: mps_fmt_auto_header_s
The type of the structure used to create an :term:`object format`
of variant auto-header. ::
typedef struct mps_fmt_auto_header_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_skip_t skip;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
size_t mps_headerSize;
} mps_fmt_auto_header_s;
Variant auto-header is the same as variant A except for the
removal of the unused ``copy`` method, and the addition of the
``mps_headerSize`` field. See :c:type:`mps_fmt_A_s`.
.. c:function:: mps_res_t mps_fmt_create_auto_header(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_auto_header_s *fmt_ah)
Create an :term:`object format` based on a description of an
object format of variant auto-header.
.. c:type:: mps_fmt_fixed_s
The type of the structure used to create an :term:`object format`
of variant fixed. ::
typedef struct mps_fmt_fixed_s {
mps_align_t align;
mps_fmt_scan_t scan;
mps_fmt_fwd_t fwd;
mps_fmt_isfwd_t isfwd;
mps_fmt_pad_t pad;
} mps_fmt_fixed_s;
Variant fixed is the same as variant A except for the removal of
the unused ``copy`` method, and the lack of a ``skip`` method
(this is not needed because the objects are fixed in size). See
:c:type:`mps_fmt_A_s`.
.. c:function:: mps_res_t mps_fmt_create_fixed(mps_fmt_t *fmt_o, mps_arena_t arena, mps_fmt_fixed_s *fmt_fixed)
Create an :term:`object format` based on a description of an
object format of variant fixed.

94
mps/manual/html/_sources/topic/keyword.txt
View file

@ -54,39 +54,21 @@ now :c:macro:`MPS_KEY_ARGS_END`.
typedef struct mps_arg_s {
mps_key_t key;
union {
mps_bool_t b;
char c;
const char *string;
int i;
unsigned u;
long l;
unsigned long ul;
size_t size;
mps_addr_t addr;
mps_fmt_t format;
mps_chain_t chain;
struct mps_pool_debug_option_s *pool_debug_options;
mps_addr_t (*addr_method)(mps_addr_t);
mps_align_t align;
mps_word_t count;
void *p;
mps_rank_t rank;
} val;
union { /* many fields; see table below */ } val;
} mps_arg_s;
``key`` identifies the key. It must be one of the legal values
of :c:type:`mps_key_t` listed in the documentation for that type.
``key`` identifies the key. It must be one of the values listed in
the documentation for the type :c:type:`mps_key_t`.
``val`` is the corresponding value. The table given in the
documentation for :c:type:`mps_key_t` explains which structure
field is used by that keyword.
``val`` is the corresponding value. This union contains many
fields: one for each keyword argument type. The table given in the
documentation for :c:type:`mps_key_t` below indicates which
structure field is used by each keyword.
.. note::
If you use the convenience macros :c:func:`MPS_ARGS_ADD` and
:c:func:`MPS_ARG` you don't need to know the name of the
field.
If you use the convenience macro :c:func:`MPS_ARGS_ADD` then
you don't need to know the name of the field.
.. c:macro:: mps_args_none
@ -102,31 +84,39 @@ now :c:macro:`MPS_KEY_ARGS_END`.
The type of :term:`keyword argument` keys. Must take one of the
following values:
======================================== ====================== ==========================================================
Keyword Field See
======================================== ====================== ==========================================================
:c:macro:`MPS_KEY_ARGS_END` *none* *see above*
:c:macro:`MPS_KEY_ALIGN` ``align`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_AMS_SUPPORT_AMBIGUOUS` ``b`` :c:func:`mps_class_ams`
:c:macro:`MPS_KEY_ARENA_CL_BASE` ``addr`` :c:func:`mps_arena_class_cl`
:c:macro:`MPS_KEY_ARENA_SIZE` ``size`` :c:func:`mps_arena_class_vm`, :c:func:`mps_arena_class_cl`
:c:macro:`MPS_KEY_AWL_FIND_DEPENDENT` ``addr_method`` :c:func:`mps_class_awl`
:c:macro:`MPS_KEY_CHAIN` ``chain`` :c:func:`mps_class_amc`, :c:func:`mps_class_amcz`, :c:func:`mps_class_ams`
:c:macro:`MPS_KEY_EXTEND_BY` ``size`` :c:func:`mps_class_mfs`, :c:func:`mps_class_mv`, :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_FORMAT` ``format`` :c:func:`mps_class_amc`, :c:func:`mps_class_amcz`, :c:func:`mps_class_ams`, :c:func:`mps_class_awl`, :c:func:`mps_class_lo` , :c:func:`mps_class_snc`
:c:macro:`MPS_KEY_MAX_SIZE` ``size`` :c:func:`mps_class_mv`
:c:macro:`MPS_KEY_MEAN_SIZE` ``size`` :c:func:`mps_class_mv`, :c:func:`mps_class_mvt`, :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MFS_UNIT_SIZE` ``size`` :c:func:`mps_class_mfs`
:c:macro:`MPS_KEY_MIN_SIZE` ``size`` :c:func:`mps_class_mvt`
:c:macro:`MPS_KEY_MVFF_ARENA_HIGH` ``b`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MVFF_FIRST_FIT` ``b`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MVFF_SLOT_HIGH` ``b`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MVT_FRAG_LIMIT` ``count`` :c:func:`mps_class_mvt`
:c:macro:`MPS_KEY_MVT_RESERVE_DEPTH` ``count`` :c:func:`mps_class_mvt`
:c:macro:`MPS_KEY_POOL_DEBUG_OPTIONS` ``pool_debug_options`` :c:func:`mps_class_ams_debug`, :c:func:`mps_class_mv_debug`, :c:func:`mps_class_mvff_debug`
:c:macro:`MPS_KEY_RANK` ``rank`` :c:func:`mps_class_awl`, :c:func:`mps_class_snc`
:c:macro:`MPS_KEY_VMW3_TOP_DOWN` ``b`` :c:func:`mps_arena_class_vm`
======================================== ====================== ==========================================================
======================================== ====================================================== ==========================================================
Keyword Type & field in ``arg.val`` See
======================================== ====================================================== ==========================================================
:c:macro:`MPS_KEY_ARGS_END` *none* *see above*
:c:macro:`MPS_KEY_ALIGN` :c:type:`mps_align_t` ``align`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_AMS_SUPPORT_AMBIGUOUS` :c:type:`mps_bool_t` ``b`` :c:func:`mps_class_ams`
:c:macro:`MPS_KEY_ARENA_CL_BASE` :c:type:`mps_addr_t` ``addr`` :c:func:`mps_arena_class_cl`
:c:macro:`MPS_KEY_ARENA_SIZE` :c:type:`size_t` ``size`` :c:func:`mps_arena_class_vm`, :c:func:`mps_arena_class_cl`
:c:macro:`MPS_KEY_AWL_FIND_DEPENDENT` ``void *(*)(void *)`` ``addr_method`` :c:func:`mps_class_awl`
:c:macro:`MPS_KEY_CHAIN` :c:type:`mps_chain_t` ``chain`` :c:func:`mps_class_amc`, :c:func:`mps_class_amcz`, :c:func:`mps_class_ams`
:c:macro:`MPS_KEY_EXTEND_BY` :c:type:`size_t` ``size`` :c:func:`mps_class_mfs`, :c:func:`mps_class_mv`, :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_FMT_ALIGN` :c:type:`mps_align_t` ``align`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_CLASS` :c:type:`mps_fmt_class_t` ``fmt_class`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_FWD` :c:type:`mps_fmt_fwd_t` ``fmt_fwd`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_HEADER_SIZE` :c:type:`size_t` ``size`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_ISFWD` :c:type:`mps_fmt_isfwd_t` ``fmt_isfwd`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_PAD` :c:type:`mps_fmt_pad_t` ``fmt_pad`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_SCAN` :c:type:`mps_fmt_scan_t` ``fmt_scan`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FMT_SKIP` :c:type:`mps_fmt_skip_t` ``fmt_skip`` :c:func:`mps_fmt_create_k`
:c:macro:`MPS_KEY_FORMAT` :c:type:`mps_fmt_t` ``format`` :c:func:`mps_class_amc`, :c:func:`mps_class_amcz`, :c:func:`mps_class_ams`, :c:func:`mps_class_awl`, :c:func:`mps_class_lo` , :c:func:`mps_class_snc`
:c:macro:`MPS_KEY_MAX_SIZE` :c:type:`size_t` ``size`` :c:func:`mps_class_mv`
:c:macro:`MPS_KEY_MEAN_SIZE` :c:type:`size_t` ``size`` :c:func:`mps_class_mv`, :c:func:`mps_class_mvt`, :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MFS_UNIT_SIZE` :c:type:`size_t` ``size`` :c:func:`mps_class_mfs`
:c:macro:`MPS_KEY_MIN_SIZE` :c:type:`size_t` ``size`` :c:func:`mps_class_mvt`
:c:macro:`MPS_KEY_MVFF_ARENA_HIGH` :c:type:`mps_bool_t` ``b`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MVFF_FIRST_FIT` :c:type:`mps_bool_t` ``b`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MVFF_SLOT_HIGH` :c:type:`mps_bool_t` ``b`` :c:func:`mps_class_mvff`
:c:macro:`MPS_KEY_MVT_FRAG_LIMIT` :c:type:`mps_count_t` ``count`` :c:func:`mps_class_mvt`
:c:macro:`MPS_KEY_MVT_RESERVE_DEPTH` :c:type:`mps_count_t` ``count`` :c:func:`mps_class_mvt`
:c:macro:`MPS_KEY_POOL_DEBUG_OPTIONS` ``mps_pool_debug_options_s *`` ``pool_debug_options`` :c:func:`mps_class_ams_debug`, :c:func:`mps_class_mv_debug`, :c:func:`mps_class_mvff_debug`
:c:macro:`MPS_KEY_RANK` :c:type:`mps_rank_t` ``rank`` :c:func:`mps_class_awl`, :c:func:`mps_class_snc`
:c:macro:`MPS_KEY_VMW3_TOP_DOWN` :c:type:`mps_bool_t` ``b`` :c:func:`mps_arena_class_vm`
======================================== ====================================================== ==========================================================
.. c:function:: MPS_ARGS_BEGIN(args)

21
mps/manual/html/_sources/topic/pool.txt
View file

@ -81,6 +81,27 @@ making it available for allocation.
:term:`allocation points` and :term:`segregated allocation caches`
created in the pool.
.. warning::
It is not safe to destroy an :term:`automatically managed
<automatic memory management>` pool if it contains any objects
that are :term:`reachable` from your roots, or any objects
that have been registered for :term:`finalization` but not yet
finalized, and then to carry on running the :term:`garbage
collector`.
Our recommended approach is to destroy automatically managed
pools just before destroying the arena, and then only while
the arena is in the :term:`parked state`. Thus a safe
tear-down sequence looks like this::
mps_arena_park(arena);
/* destroy threads and roots belonging to the arena */
/* destroy allocation points and caches belonging to the pool */
mps_pool_destroy(pool);
/* destroy chains and formats belonging to the arena */
mps_arena_destroy(arena);
.. index::
single: pool class

11
mps/manual/html/_sources/topic/scanning.txt
View file

@ -85,8 +85,8 @@ passing them to :c:func:`MPS_FIX1` and :c:func:`MPS_FIX2`.
The reference passed to :c:func:`MPS_FIX2` must be the address of the
base of the block referred to (unless the referent belongs to an
:term:`object format` of variant auto-header, in which case it must be
a reference to the address just after the header).
:term:`object format` with :term:`in-band headers`, in which case it
must be a reference to the address just after the header).
However, :c:func:`MPS_FIX1` allows some leeway: if you pass it a
reference to the interior of an allocated block, then
@ -116,7 +116,7 @@ is not of interest to the MPS.
Similarly, if you use interior pointers, you do not need to convert
them to base pointers before calling :c:func:`MPS_FIX1` (or, indeed,
before calling :c:func:`MPS_FIX2`, if the target of the referent
belongs to an :term:`object format` of variant auto-header).
belongs to an :term:`object format` with :term:`in-band headers`).
.. index::
@ -485,9 +485,8 @@ Fixing interface
afterwards.
The only exception is for references to objects belonging to a
format of variant auto-header (see
:c:type:`mps_fmt_auto_header_s`): the header size must not be
subtracted from these references.
format with :term:`in-band headers`: the header size must not
be subtracted from these references.
.. note::

BIN
mps/manual/html/_static/SourceCodePro-Bold.ttf
View file

Binary file not shown.

BIN
mps/manual/html/_static/SourceCodePro-Regular.ttf
View file

Binary file not shown.

35
mps/manual/html/_static/font/ubuntu-mono/Ubuntu Font License 1.0.txt Executable file
View file

@ -0,0 +1,35 @@
------------------------------- UBUNTU FONT LICENSE Version 1.0 -------------------------------
PREAMBLE
This License allows the licensed fonts to be used, studied, modified and redistributed freely. The fonts, including any derivative works, can be bundled, embedded, and redistributed provided the terms of this license are met. The fonts and derivatives, however, cannot be released under any other license. The requirement for fonts to remain under this license does not require any document created using the fonts or their derivatives to be published under this license, as long as the primary purpose of the document is not to be a vehicle for the distribution of the fonts.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation.
"Original Version" refers to the collection of Font Software components as received under this license.
"Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment.
"Copyright Holder(s)" refers to all individuals and companies who have a copyright ownership of the Font Software.
"Substantially Changed" refers to Modified Versions which can be easily identified as dissimilar to the Font Software by users of the Font Software comparing the Original Version with the Modified Version.
To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification and with or without charging a redistribution fee), making available to the public, and in some countries other activities as well.
PERMISSION & CONDITIONS
This license does not grant any rights under trademark law and all such rights are reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to propagate the Font Software, subject to the below conditions:
1) Each copy of the Font Software must contain the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine- readable metadata fields within text or binary files as long as those fields can be easily viewed by the user.
2) The font name complies with the following: (a) The Original Version must retain its name, unmodified. (b) Modified Versions which are Substantially Changed must be renamed to avoid use of the name of the Original Version or similar names entirely. (c) Modified Versions which are not Substantially Changed must be renamed to both (i) retain the name of the Original Version and (ii) add additional naming elements to distinguish the Modified Version from the Original Version. The name of such Modified Versions must be the name of the Original Version, with "derivative X" where X represents the name of the new work, appended to that name.
3) The name(s) of the Copyright Holder(s) and any contributor to the Font Software shall not be used to promote, endorse or advertise any Modified Version, except (i) as required by this license, (ii) to acknowledge the contribution(s) of the Copyright Holder(s) or (iii) with their explicit written permission.
4) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not affect any document created using the Font Software, except any version of the Font Software extracted from a document created using the Font Software may only be distributed under this license.
TERMINATION
This license becomes null and void if any of the above conditions are not met.
DISCLAIMER THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-B-webfont.eot Executable file
View file

Binary file not shown.

146
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-B-webfont.svg Executable file
View file

@ -0,0 +1,146 @@
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg">
<metadata>
This is a custom SVG webfont generated by Font Squirrel.
Copyright : Copyright 2011 Canonical Ltd Licensed under the Ubuntu Font Licence 10
Designer : Dalton Maag Ltd
Foundry : Dalton Maag Ltd
Foundry URL : httpwwwdaltonmaagcom
</metadata>
<defs>
<font id="UbuntuMonoBold" horiz-adv-x="1024" >
<font-face units-per-em="2048" ascent="1638" descent="-410" />
<missing-glyph horiz-adv-x="500" />
<glyph unicode=" " />
<glyph unicode="!" d="M342 145q0 78 52 123t118 45t118 -45t52 -123q0 -80 -52 -125t-118 -45t-118 45t-52 125zM367 932v336h290v-336q0 -74 -3 -132.5t-8 -112.5t-12 -107l-16 -119h-208q-10 66 -17.5 120t-13.5 107t-9 111.5t-3 132.5z" />
<glyph unicode="&#x22;" d="M178 1292v99h268v-101q0 -51 -5 -111.5t-14 -124t-20 -124.5l-22 -115h-145q-10 53 -20.5 114.5t-20 125t-15.5 125t-6 112.5zM582 1292v99h268v-101q0 -51 -5 -111.5t-14.5 -124l-19.5 -125t-20 -114.5h-148q-10 53 -20.5 114.5t-19.5 125t-15 125t-6 112.5z" />
<glyph unicode="#" d="M37 313v209h162l43 226h-205v208h246l59 312h209l-62 -312h164l60 312h209l-60 -312h127v-208h-168l-43 -226h211v-209h-250l-59 -313h-209l59 313h-163l-58 -313h-209l60 313h-123zM408 522h163l41 226h-161z" />
<glyph unicode="$" d="M70 111l77 200q66 -31 154 -56.5t186 -25.5q115 0 160 30t45 93q0 37 -17.5 63.5t-51 48t-82.5 39.5l-111 40q-59 20 -116.5 46.5t-102.5 64.5t-72.5 92.5t-27.5 134.5q0 57 15 110t49 98.5t89 79t135 52.5v198h234v-188q94 -8 166.5 -28.5t113.5 -37.5l-57 -211 q-59 25 -140 44.5t-167 19.5q-98 0 -136 -35t-38 -82q0 -33 13 -54.5t41 -37.5t67 -31.5t92 -34.5q80 -31 147.5 -64.5t116.5 -77.5t76.5 -103.5t27.5 -139.5q0 -55 -16 -109t-54 -100.5t-100.5 -80t-156.5 -48.5v-219h-234v217q-129 12 -207.5 41t-117.5 52z" />
<glyph unicode="%" d="M4 0l834 1268h182l-834 -1268h-182zM20 979q0 156 61.5 236.5t166.5 80.5q111 0 172 -80.5t61 -236.5t-61.5 -238t-171.5 -82q-104 0 -166 82t-62 238zM182 979q0 -86 18.5 -121t47.5 -35q27 0 47 35t20 121t-20.5 122t-46.5 36q-29 0 -47.5 -36t-18.5 -122zM543 290.5 q0 155.5 61.5 236.5t167.5 81q109 0 170.5 -81t61.5 -236.5t-61.5 -236.5t-170.5 -81q-106 0 -167.5 81t-61.5 236.5zM707 291q0 -86 17 -121t46 -35t49.5 35t20.5 121t-20.5 123t-49.5 37t-46 -37t-17 -123z" />
<glyph unicode="&#x26;" d="M43 334q0 98 50 187t151 151q-49 68 -81 141.5t-32 153.5q0 82 28.5 144.5t76 103t105.5 61t120 20.5q57 0 112.5 -18t98.5 -54t69.5 -90.5t26.5 -125.5q0 -98 -59.5 -191.5t-186.5 -159.5l86 -100l92 -104q29 104 31 247l209 -26q-2 -115 -29.5 -213.5t-70.5 -177.5 q49 -68 88 -139.5t59 -143.5h-239q-23 59 -50 109q-70 -61 -143.5 -93t-144.5 -32q-92 0 -161 28.5t-115 76.5t-68.5 111.5t-22.5 133.5zM258 346q0 -70 36 -121t122 -51q47 0 94 18.5t88 63.5q-57 72 -119 139l-121 133q-45 -31 -72.5 -75t-27.5 -107zM348 979 q0 -45 18.5 -91t51.5 -95q66 37 100.5 97t34.5 116q0 53 -25.5 80.5t-66.5 27.5q-51 0 -82 -34.5t-31 -100.5z" />
<glyph unicode="'" d="M381 1255v136h268v-136q0 -51 -5 -111.5t-14 -124t-19.5 -126t-20.5 -115.5h-148q-10 53 -20 115.5l-19.5 126t-15.5 124t-6 111.5z" />
<glyph unicode="(" d="M193 545q0 283 133 519t411 390l117 -156q-197 -115 -312.5 -307t-115.5 -446q0 -252 111.5 -437.5t308.5 -300.5l-117 -155q-279 154 -407.5 383t-128.5 510z" />
<glyph unicode=")" d="M174 1298l117 156q279 -154 412 -390.5t133 -518.5q0 -281 -129 -510.5t-408 -382.5l-117 155q197 115 308.5 300.5t111.5 437.5q0 254 -115.5 446t-312.5 307z" />
<glyph unicode="*" d="M94 881l76 223l61 -19q23 -8 53.5 -25.5t61.5 -37.5l61 -41q30 -20 50 -37l-18.5 58.5t-19.5 70.5t-15.5 72t-6.5 59v64h238v-64q0 -25 -6 -59.5t-15.5 -71.5t-20.5 -71l-20 -58l52 35l62 40l62.5 35.5t55.5 24.5l59 21l74 -228l-61 -18q-25 -8 -60 -12t-71.5 -7.5 t-72.5 -3.5h-63q23 -14 52 -35l57 -45q29 -24 53.5 -48.5t38.5 -45.5l39 -51l-193 -139l-36 51q-14 20 -30 51t-30 67t-25 70l-20 60q-6 -25 -18 -59l-26 -70q-13 -35 -28.5 -65.5t-29.5 -51.5l-39 -51l-193 137l39 51q14 20 40 45l53 50q28 25 57 46l49 36h-63 q-36 0 -72.5 3t-71.5 9t-57 14z" />
<glyph unicode="+" d="M82 434v207h321v356h218v-356h321v-207h-321v-356h-218v356h-321z" />
<glyph unicode="," d="M258 -150q37 8 75 14.5t71.5 19t60.5 35t43 61.5q-78 8 -121 61t-43 119q0 80 52.5 131t131.5 51q86 0 134.5 -57.5t48.5 -155.5q0 -72 -22.5 -143.5t-73 -133t-130 -106.5t-194.5 -59z" />
<glyph unicode="-" d="M231 401v248h562v-248h-562z" />
<glyph unicode="." d="M330 162q0 43 15 76.5t41 56t58.5 35t69.5 12.5q72 0 127 -47t55 -133q0 -90 -55 -137.5t-127 -47.5q-37 0 -69.5 12.5t-58.5 36t-41 57.5t-15 79z" />
<glyph unicode="/" d="M96 -338l574 1770h258l-570 -1770h-262z" />
<glyph unicode="0" d="M72 637q0 332 114.5 495.5t325.5 163.5q215 0 327.5 -162.5t112.5 -496.5q0 -336 -112.5 -500t-327.5 -164t-327.5 164t-112.5 500zM299 637q0 -219 55.5 -333t157.5 -114q104 0 158.5 114t54.5 333q0 217 -54.5 330.5t-158.5 113.5q-102 0 -157.5 -113.5t-55.5 -330.5z M399 657.5q0 55.5 31 96.5t84 41q49 0 81 -41t32 -96.5t-32 -95.5t-81 -40q-53 0 -84 40t-31 95.5z" />
<glyph unicode="1" d="M98 1004q49 18 106.5 46.5t115 63.5t108.5 74t88 80h172v-1059h252v-209h-770v209h266v709q-57 -41 -131 -73t-125 -50z" />
<glyph unicode="2" d="M88 1128q82 86 189.5 127t214.5 41q78 0 149.5 -22.5t126.5 -67.5t88 -113.5t33 -158.5q0 -66 -24.5 -126t-65.5 -117.5t-92.5 -111t-104.5 -102.5l-61 -58q-35 -34 -66 -70t-52.5 -72.5t-21.5 -67.5h545v-209h-827q-6 20 -5 51t1 43q0 102 37.5 188.5t96 159 t125.5 135.5l125 119q58 57 96 110.5t38 108.5q0 78 -47 120t-119 42q-59 0 -125 -28.5t-129 -96.5z" />
<glyph unicode="3" d="M84 43l49 211q47 -20 122 -43t179 -23q129 0 181.5 55.5t52.5 137.5q0 100 -80 140t-203 40h-78v209h94q39 0 78 8t70 26.5t50 49.5t19 78q0 70 -41.5 109.5t-115.5 39.5q-72 0 -142.5 -23.5t-121.5 -58.5l-91 185q55 37 146.5 74.5t206.5 37.5q106 0 185 -26.5 t130 -74.5t75.5 -113.5t24.5 -141.5t-43 -145.5t-114 -106.5q98 -41 152.5 -121t54.5 -190q0 -88 -29 -162t-88 -128t-151.5 -84t-219.5 -30q-47 0 -99 7.5t-100.5 17.5t-89 22.5t-63.5 22.5z" />
<glyph unicode="4" d="M55 299v184q39 80 100.5 181.5t135.5 208t155.5 210t163.5 185.5h226v-762h137v-207h-137v-299h-252v299h-529zM297 506h287v446l-76 -100q-39 -53 -77 -111.5t-72.5 -118t-61.5 -116.5z" />
<glyph unicode="5" d="M72 39l51 209q45 -23 114.5 -41.5t174.5 -18.5q74 0 122 16.5t75.5 42t37.5 58.5t10 68q0 53 -17 97t-69.5 76t-148.5 49t-252 17q20 172 32.5 337t18.5 319h647v-209h-436q-4 -66 -10 -137l-10 -117q254 -16 378.5 -123t124.5 -299q0 -88 -30.5 -163t-94 -130 t-157.5 -86t-219 -31q-49 0 -100.5 6.5t-98.5 15.5t-85 21.5t-58 22.5z" />
<glyph unicode="6" d="M94 518q0 184 54.5 325.5t154.5 238t241.5 145.5t313.5 49l14 -215q-82 -2 -159.5 -16.5t-143 -48t-113.5 -87t-71 -133.5q39 16 76 25.5t65 9.5q111 0 188 -33t126 -88t70.5 -129t21.5 -155q0 -74 -23.5 -150t-73 -139.5t-125 -103.5t-180.5 -40q-213 0 -324.5 132 t-111.5 413zM342 496q0 -59 8 -113.5t28.5 -97.5t56.5 -69t89 -26q43 0 74 20.5t50.5 51.5t28.5 68t9 71q0 96 -43 148.5t-149 52.5q-39 0 -80 -8t-68 -23q-2 -18 -3 -36.5t-1 -38.5z" />
<glyph unicode="7" d="M100 1059v209h828v-191q-55 -63 -121 -178t-124 -260t-102 -310t-55 -329h-256q6 131 43 277.5t89.5 290t114 271.5t116.5 220h-533z" />
<glyph unicode="8" d="M78 317q0 96 45 181.5t141 150.5q-90 61 -122.5 131t-32.5 148q0 61 21.5 127.5t68.5 120t124.5 88t192.5 34.5q182 0 289.5 -90t107.5 -241q0 -88 -43 -173t-135 -143q117 -68 165 -147.5t48 -175.5q0 -61 -23.5 -125t-75.5 -114t-136 -83t-207 -33q-96 0 -175 23.5 t-135.5 68t-87 108.5t-30.5 144zM313 348q0 -82 58.5 -124t138.5 -42q92 0 146.5 44t54.5 106q0 41 -15.5 71.5t-49.5 56t-87 51.5t-127 54q-57 -47 -88 -105.5t-31 -111.5zM346 944q0 -72 47 -117t166 -94q63 47 90 103.5t27 109.5q0 72 -48 108t-116 36q-66 0 -116 -37 t-50 -109z" />
<glyph unicode="9" d="M92 868q0 74 25.5 151t76 139.5t126 102t178.5 39.5q213 0 325.5 -143t112.5 -399q0 -184 -53.5 -326.5t-152.5 -239t-239.5 -146.5t-312.5 -50l-8 217q164 2 293 70.5t182 216.5q-80 -35 -143 -35q-111 0 -188.5 31.5t-127 87t-72 128t-22.5 156.5zM338 872 q0 -96 45 -147t152 -51q39 0 81.5 8t69.5 23q2 16 3 39.5t1 46.5q0 51 -9 103t-30.5 95t-57.5 69.5t-89 26.5q-45 0 -77 -17t-51.5 -46t-28.5 -68t-9 -82z" />
<glyph unicode=":" d="M330 162q0 43 15 76.5t41 56t58.5 35t69.5 12.5q72 0 127 -47t55 -133q0 -90 -55 -137.5t-127 -47.5q-37 0 -69.5 12.5t-58.5 36t-41 57.5t-15 79zM330 782q0 43 15 77t41 56.5t58.5 35t69.5 12.5q72 0 127 -47.5t55 -133.5q0 -90 -55 -137t-127 -47q-37 0 -69.5 12.5 t-58.5 36t-41 57t-15 78.5z" />
<glyph unicode=";" d="M242 -150q37 8 74.5 14.5t71.5 19t60.5 35t43.5 61.5q-78 8 -121 61t-43 119q0 80 52 131t132 51q86 0 134 -57.5t48 -155.5q0 -72 -22.5 -143.5t-72.5 -133t-130 -106.5t-195 -59zM330 782q0 43 15 77t41 56.5t58.5 35t69.5 12.5q72 0 127 -47.5t55 -133.5 q0 -90 -55 -137t-127 -47q-37 0 -69.5 12.5t-58.5 36t-41 57t-15 78.5z" />
<glyph unicode="&#x3c;" d="M92 414v227l787 330l69 -221l-573 -224l573 -223l-69 -221z" />
<glyph unicode="=" d="M82 233v209h860v-209h-860zM82 633v209h860v-209h-860z" />
<glyph unicode="&#x3e;" d="M82 301l575 223l-575 224l72 221l786 -330v-227l-786 -332z" />
<glyph unicode="?" d="M141 1202q72 45 168.5 69.5t190.5 24.5q117 0 192.5 -31.5t118.5 -78.5t60.5 -103.5t17.5 -107.5q0 -59 -23.5 -108.5t-59.5 -92.5t-77 -81l-77 -74.5t-59.5 -75.5t-23.5 -82h-229q-2 10 -2 31q0 82 43 156.5t113 131.5q47 39 88 83t41 95q0 61 -43 93t-108.5 32 t-127 -19.5t-133.5 -53.5zM299 145q0 39 14.5 71t39 53.5t55 32.5t63.5 11t63.5 -11t54 -32.5t38 -53.5t14.5 -71q0 -80 -52 -125t-118 -45q-33 0 -63.5 11.5t-55 34t-39 53t-14.5 71.5z" />
<glyph unicode="@" d="M37 508q0 221 42 371.5t113.5 244t164 133t194.5 39.5q84 0 157.5 -25.5t129 -80.5t88 -144.5t32.5 -216.5v-716q-55 -23 -127.5 -34t-125.5 -11q-78 0 -144.5 23.5t-116 73.5t-77 131t-27.5 198q0 86 15.5 161.5t52 132t95 89t144.5 32.5q39 0 96 -10v33q0 78 -49 132 t-143 54q-68 0 -128.5 -28.5t-104.5 -100t-69.5 -191.5t-25.5 -302q0 -143 21.5 -254t74 -185.5t139.5 -113.5t216 -39q96 0 151.5 10t71.5 16l23 -178q-35 -8 -64 -13t-57.5 -8t-58 -5t-66.5 -2q-135 0 -252 36.5t-202 128t-134 242t-49 377.5zM555 506q0 -39 5 -80 t19.5 -74t40 -54.5t66.5 -21.5q27 0 57 7v409q-16 4 -30.5 6t-28.5 2q-39 0 -63.5 -17t-39 -45t-20.5 -62.5t-6 -69.5z" />
<glyph unicode="A" d="M18 0q90 375 183 683l178 585h274q90 -279 179.5 -591t173.5 -677h-271l-59 293h-338l-57 -293h-263zM385 502h248l-25 131q-12 63 -27 126l-33 127l-38 136l-38 -136l-33 -127q-15 -62 -28.5 -125.5t-25.5 -131.5z" />
<glyph unicode="B" d="M111 20v1231q72 12 157.5 21.5t169.5 9.5q143 0 233.5 -29.5t141.5 -78t69.5 -107.5t18.5 -119q0 -90 -44 -159.5t-118 -110.5q129 -47 175.5 -127t46.5 -168q0 -115 -39 -191.5t-105.5 -122.5t-158 -65.5t-195.5 -19.5q-84 0 -174 9t-178 27zM362 555v-344q27 -4 59 -6 t62 -2q43 0 84 7t73 26.5t52.5 55.5t20.5 91q0 92 -58.5 132t-156.5 40h-136zM362 764h99q96 0 145 42t49 116q0 45 -14 72.5t-38.5 43t-57.5 20.5t-68 5q-29 0 -60 -2t-55 -6v-291z" />
<glyph unicode="C" d="M55 635q0 158 43 280.5t120 207.5t182.5 129t230.5 44q68 0 122 -11t95 -25.5t68 -30.5l42 -25l-65 -200q-47 31 -113.5 52t-152.5 21q-59 0 -115.5 -21.5t-100.5 -71.5t-72 -134t-28 -209q0 -217 75 -332.5t245 -115.5q98 0 162.5 22.5t103.5 44.5l64 -199 q-53 -33 -144.5 -60.5t-210.5 -27.5q-268 0 -409.5 172.5t-141.5 489.5z" />
<glyph unicode="D" d="M111 14v1237q86 18 161.5 24.5t141.5 6.5q125 0 228 -37t175 -115.5t112 -200.5t40 -294q0 -176 -44 -300t-122 -202t-185.5 -113.5t-236.5 -35.5q-68 0 -132 7t-138 23zM362 205q10 -2 23 -2h23q86 0 144 32.5t94 90t51.5 136.5t15.5 173q0 82 -12.5 159.5t-43 137 t-84 95.5t-137.5 36q-16 0 -36.5 -1t-37.5 -5v-852z" />
<glyph unicode="E" d="M129 0v1268h768v-209h-516v-285h448v-209h-448v-356h561v-209h-813z" />
<glyph unicode="F" d="M129 0v1268h776v-209h-524v-307h459v-209h-459v-543h-252z" />
<glyph unicode="G" d="M55 635q0 162 43 285.5t117 207.5t174 126t215 42q74 0 132.5 -11t101.5 -25.5t70 -30.5l42 -25l-65 -200q-45 29 -110.5 51t-135.5 22q-90 0 -151.5 -32.5t-101.5 -91t-57.5 -139.5t-17.5 -179q0 -227 72 -334.5t211 -107.5q23 0 49.5 2t48.5 6v463h252v-633 q-45 -16 -140 -37t-231 -21q-119 0 -214 42t-162.5 125t-104.5 207t-37 288z" />
<glyph unicode="H" d="M92 0v1268h252v-500h336v500h252v-1268h-252v559h-336v-559h-252z" />
<glyph unicode="I" d="M111 0v209h276v850h-276v209h804v-209h-274v-850h274v-209h-804z" />
<glyph unicode="J" d="M86 86l96 201q51 -33 113.5 -63.5t128.5 -30.5q98 0 158.5 52t60.5 193v621h-424v209h678v-844q0 -92 -23.5 -174t-78 -143.5t-140.5 -97.5t-209 -36q-129 0 -215 33t-145 80z" />
<glyph unicode="K" d="M92 0v1268h252v-527q45 57 94 127t93 139.5t81 137t62 123.5h284l-68.5 -126t-90.5 -148l-110 -156q-58 -80 -122 -154q63 -61 129 -141t124.5 -171t105.5 -186.5t75 -185.5h-284q-23 72 -65 155t-93 161.5t-107.5 147t-107.5 116.5v-580h-252z" />
<glyph unicode="L" d="M145 0v1268h254v-1059h543v-209h-797z" />
<glyph unicode="M" d="M47 0l13 324q7 168 15.5 333.5t19.5 321.5t26 289h209l36 -111l46 -145l49 -158l47 -147l51 156l51 156l45 140q20 66 37 109h209l28 -324q13 -158 22.5 -312.5t15.5 -311t10 -320.5h-232l13 985l-156 -536h-184l-150 536l11 -985h-232z" />
<glyph unicode="N" d="M94 0v1268h203q57 -90 115 -196l111 -210l101 -203l78 -172v781h228v-1268h-203q-86 211 -187.5 421t-217.5 421v-842h-228z" />
<glyph unicode="O" d="M55 635q0 328 121 494.5t336 166.5q223 0 340 -166.5t117 -494.5t-119 -495t-336 -167q-223 0 -341 167t-118 495zM311 635q0 -92 7.5 -173t29 -140.5t60 -94t104.5 -34.5q63 0 103 34.5t61.5 95t29 140.5t7.5 172t-7.5 173t-29 140.5t-60 94t-104.5 34.5t-104.5 -34.5 t-60 -95t-29 -140.5t-7.5 -172z" />
<glyph unicode="P" d="M111 0v1251q37 8 83 14.5t93 9.5t92 5t80 2q242 0 375 -99.5t133 -324.5q0 -227 -134.5 -328.5t-379.5 -101.5h-91v-428h-251zM362 647h103q121 0 182.5 48t61.5 165q0 111 -60.5 157t-161.5 46q-22 0 -62 -1t-63 -5v-410z" />
<glyph unicode="Q" d="M55 629q0 328 121 494.5t336 166.5q223 0 340 -167t117 -494q0 -287 -92.5 -452t-266.5 -200q23 -51 110 -84.5t238 -60.5l-53 -180q-240 33 -361.5 109.5t-144.5 220.5q-166 41 -255 203.5t-89 443.5zM311 629q0 -92 7.5 -172t29 -140.5t60 -95.5t104.5 -35q63 0 103 35 t61.5 95.5t29 140.5t7.5 172t-7.5 173t-29 140t-60 94t-104.5 35t-104.5 -35t-60 -95t-29 -140t-7.5 -172z" />
<glyph unicode="R" d="M111 0v1249q37 8 81 15.5t89 10.5t86 5t71 2q109 0 197 -24.5t151.5 -76t97.5 -130t34 -185.5q0 -111 -45.5 -201t-149.5 -137l74 -117q39 -65 75 -136l71 -141q34 -71 58 -134h-264q-47 123 -109.5 236.5t-133.5 230.5h-132v-467h-251zM362 676h56q129 0 186 50t57 142 q0 100 -61 147.5t-162 47.5q-14 0 -34.5 -1t-41.5 -5v-381z" />
<glyph unicode="S" d="M82 70l74 204q55 -33 132 -61.5t187 -28.5q63 0 105.5 13.5t67 37t33.5 53t9 60.5q0 39 -22.5 70t-57.5 54.5t-78 43t-86 35.5q-57 20 -118.5 47t-111.5 68t-83 101t-33 151q0 178 116 278t319 100q117 0 203.5 -26.5t146.5 -59.5l-74 -194q-51 29 -113.5 49t-144.5 20 q-201 0 -201 -145q0 -37 20.5 -64.5t52.5 -49t72 -38t78 -30.5l124 -50.5t119 -73.5t89 -114.5t35 -173.5q0 -178 -115.5 -275.5t-351.5 -97.5q-158 0 -252 34t-141 63z" />
<glyph unicode="T" d="M51 1059v209h922v-209h-334v-1059h-254v1059h-334z" />
<glyph unicode="U" d="M80 459v809h254v-793q0 -80 8 -134t27.5 -87t54.5 -47t88 -14t88 14t55.5 48t28.5 88t8 134v791h252v-809q0 -111 -20.5 -201t-71.5 -153.5t-135 -97.5t-209 -34q-123 0 -206 34t-132 97.5t-69.5 153.5t-20.5 201z" />
<glyph unicode="V" d="M27 1268h266q12 -98 36.5 -228.5t54.5 -268.5t63.5 -272t66.5 -241q33 104 65.5 238.5t61.5 272.5t53.5 269t40.5 230h264q-25 -123 -60.5 -274.5t-81.5 -318.5t-101.5 -340t-114.5 -335h-260q-49 141 -104.5 319.5t-104.5 355.5t-88 335t-57 258z" />
<glyph unicode="W" d="M47 1268h234l-5 -250l-4 -257l-4 -250q-2 -122 -2 -228l42 143l45 154l40 139l29 100h184q8 -39 25 -96l36 -127l43 -150l46 -163q0 106 -2 228l-4 249l-5 257q-2 130 -2 251h234l-12 -321q-6 -165 -14.5 -327.5t-19.5 -320.5t-26 -299h-209q-45 129 -90 278l-90 283 l-94 -280l-90 -281h-209q-16 141 -28.5 300t-22 321.5t-15.5 327.5t-10 319z" />
<glyph unicode="X" d="M23 0q20 55 60 133l88 168l101 185l103 184l-332 598h272l201 -406l211 406h254l-324 -592q55 -88 109 -184l99 -188q46 -91 81 -170t55 -134h-272q-39 104 -95 231l-118 254l-119 -251q-59 -130 -102 -234h-272z" />
<glyph unicode="Y" d="M27 1268h270q47 -147 104.5 -300t118.5 -280q23 47 52.5 119l59.5 151.5t57 161.5l50 148h260l-77 -203q-39 -98 -82 -194.5t-92.5 -191.5l-106.5 -196v-483h-254v481q-113 199 -197.5 388.5t-162.5 398.5z" />
<glyph unicode="Z" d="M94 0v145l96 186l115 208l138 239l165 281h-487v209h790v-176l-161 -254l-138 -227l-119 -207l-108 -195h545v-209h-836z" />
<glyph unicode="[" d="M231 -338v1770h568v-197h-328v-1376h328v-197h-568z" />
<glyph unicode="\" d="M100 1432h258l574 -1770h-260z" />
<glyph unicode="]" d="M223 -141h328v1376h-328v197h570v-1770h-570v197z" />
<glyph unicode="^" d="M33 633l379 635h215l379 -635l-228 -111l-258 447l-258 -447z" />
<glyph unicode="_" d="M16 -119h992v-219h-992v219z" />
<glyph unicode="`" d="M311 1223l125 192l324 -227l-92 -137z" />
<glyph unicode="a" d="M90 295q0 84 33 141.5t88 92t127 50t149 15.5q98 0 175 -16v30q0 72 -45.5 120t-155.5 48q-72 0 -138.5 -10t-107.5 -25l-35 203q47 16 133 29.5t179 13.5q119 0 197.5 -27.5t125.5 -78t67.5 -123t20.5 -162.5v-573q-55 -12 -163.5 -29t-243.5 -17q-92 0 -167 16.5 t-128.5 54.5t-82 98.5t-28.5 148.5zM338 301q0 -66 49 -93.5t127 -27.5q41 0 80 1t68 5v222q-25 4 -60 7t-63 3q-39 0 -76 -5t-64.5 -17.5t-44 -35t-16.5 -59.5z" />
<glyph unicode="b" d="M127 29v1349l252 43v-481q53 25 102 34t99 9q94 0 165.5 -36t119.5 -102.5t73 -158.5t25 -205q0 -115 -31 -208t-90.5 -158.5t-145.5 -101.5t-196 -36q-98 0 -200.5 14.5t-172.5 37.5zM379 205q29 -6 60.5 -8t54.5 -2q98 0 155.5 66.5t57.5 225.5q0 135 -44.5 207 t-134.5 72q-41 0 -80.5 -11.5t-68.5 -27.5v-522z" />
<glyph unicode="c" d="M90 481q0 104 33 196.5t100.5 161t171 108.5t246.5 40q86 0 155.5 -12t141.5 -41l-55 -203q-41 14 -91.5 25.5t-127.5 11.5q-90 0 -150.5 -21.5t-97.5 -59.5t-53.5 -91t-16.5 -115q0 -133 75 -208.5t255 -75.5q59 0 123.5 8t118.5 26l36 -206q-53 -20 -128.5 -34 t-178.5 -14q-147 0 -252.5 39t-173 106.5t-99.5 160t-32 198.5z" />
<glyph unicode="d" d="M57 475q0 236 97.5 372t287.5 136q51 0 100.5 -11t86.5 -32v438l252 43v-1392q-70 -23 -170.5 -37.5t-196.5 -14.5q-225 0 -341 133.5t-116 364.5zM313 487q0 -129 48.5 -210.5t154.5 -81.5q31 0 57.5 2t55.5 6v524q-29 16 -66 27.5t-78 11.5q-90 0 -131 -72t-41 -207z " />
<glyph unicode="e" d="M63 473q0 127 39 223.5t102.5 161t145.5 97t168 32.5q213 0 323.5 -126t110.5 -367q0 -25 -1 -51.5t-3 -43.5h-624q0 -94 77.5 -148t200.5 -54q76 0 144.5 16t115.5 33l35 -215q-66 -23 -139.5 -38.5t-165.5 -15.5q-123 0 -220.5 32t-166 94.5t-105.5 154.5t-37 215z M324 573h385q0 39 -10.5 75t-33 64.5t-57.5 46t-86 17.5q-49 0 -85 -16.5t-59.5 -45t-36.5 -65.5t-17 -76z" />
<glyph unicode="f" d="M74 754v209h211v55q0 117 33.5 193.5t91 122.5t131 65.5t151.5 19.5q80 0 164 -14t152 -47l-43 -205q-47 16 -118 33.5t-134 17.5q-35 0 -67 -6t-55.5 -26.5t-37.5 -58.5t-14 -99v-51h395v-209h-395v-754h-254v754h-211z" />
<glyph unicode="g" d="M68 512q0 238 131 354.5t356 116.5q158 0 342 -51v-815q0 -236 -113.5 -348.5t-365.5 -112.5q-90 0 -173 18.5t-159 42.5l47 213q59 -23 125 -42t164 -19q66 0 108.5 15.5t67.5 42t35 62.5t10 77v38q-53 -20 -97 -30.5t-95 -10.5q-188 0 -285.5 119t-97.5 330zM324 512 q0 -119 43 -181.5t135 -62.5q41 0 76.5 10.5t64.5 26.5v463q-29 6 -51.5 8t-46.5 2q-221 0 -221 -266z" />
<glyph unicode="h" d="M129 0v1378l252 43v-467q31 10 74 19.5t75 9.5q106 0 178 -31.5t115 -90t61.5 -139.5t18.5 -179v-543h-252v510q0 135 -30.5 194.5t-116.5 59.5q-35 0 -69 -8t-54 -15v-741h-252z" />
<glyph unicode="i" d="M74 754v209h518v-596q0 -86 31.5 -128t105.5 -42q35 0 84 9t111 38l32 -203q-78 -37 -146.5 -50.5t-125.5 -13.5q-98 0 -164.5 29t-106.5 83t-56.5 132t-16.5 178v355h-266zM264 1239q0 76 46 119t111.5 43t113 -43t47.5 -119q0 -74 -47.5 -117t-113 -43t-111.5 43 t-46 117z" />
<glyph unicode="j" d="M100 -260l78 213q51 -29 124 -54.5t132 -25.5q63 0 98 38t35 140v703h-389v209h641v-900q0 -117 -28.5 -195.5t-79 -126.5t-119 -68.5t-148.5 -20.5q-98 0 -182 24.5t-162 63.5zM471 1239q0 76 46 119t111.5 43t112.5 -43t47 -119q0 -74 -47 -117t-112.5 -43t-111.5 43 t-46 117z" />
<glyph unicode="k" d="M129 0v1378l254 43v-839l75 91q38 48 73 99l69 99q33 48 57 92h304l-84 -103l-98 -112l-100 -111l-91 -98q51 -49 110.5 -118t116.5 -142.5t105.5 -147.5t76.5 -131h-288q-25 51 -65 115.5t-85 127t-91 119t-85 93.5v-455h-254z" />
<glyph unicode="l" d="M74 1200v209h518v-1044q0 -98 39 -133t98 -35q76 0 127 20l68 27l32 -203q-6 -4 -27.5 -14.5t-56 -21.5t-85 -19.5t-113.5 -8.5q-174 0 -254 103.5t-80 302.5v817h-266z" />
<glyph unicode="m" d="M59 0v926q80 23 158 35t137 12q53 0 95.5 -13.5t72.5 -44.5q35 23 82 40.5t98 17.5q80 0 131.5 -24.5t81 -74t40 -124t10.5 -175.5v-575h-205v588q0 57 -7.5 92t-18.5 53.5t-26.5 24.5t-31.5 6q-18 0 -39 -3t-37 -11q6 -39 10 -86.5t4 -104.5v-192h-204v221 q0 98 -19.5 137t-62.5 39q-12 0 -29.5 -2t-34.5 -6v-756h-205z" />
<glyph unicode="n" d="M129 0v932q68 18 167 34.5t216 16.5q115 0 190.5 -31.5t119.5 -90t62.5 -139.5t18.5 -179v-543h-252v510q0 135 -30.5 194.5t-124.5 59.5q-29 0 -56.5 -2t-58.5 -6v-756h-252z" />
<glyph unicode="o" d="M59 483q0 113 34 206t94.5 159.5t144.5 102.5t182 36q100 0 183 -36t143.5 -102.5t93.5 -159.5t33 -206q0 -115 -33 -208t-92.5 -160.5t-142.5 -104.5t-185 -37t-185 37t-143.5 104.5t-93.5 160.5t-33 208zM315 481q0 -129 46.5 -208.5t148.5 -79.5q98 0 148.5 79.5 t50.5 208.5t-46.5 208t-148.5 79q-98 0 -148.5 -79t-50.5 -208z" />
<glyph unicode="p" d="M129 -338v1270q70 23 171 37t200 14q223 0 342 -135t119 -367q0 -111 -25 -204t-72 -159.5t-118.5 -103.5t-165.5 -37q-96 0 -199 48v-363h-252zM381 231q25 -16 65.5 -26t81.5 -10q90 0 133.5 72.5t43.5 205.5q0 129 -51.5 212t-155.5 83q-29 0 -62 -3l-55 -5v-529z" />
<glyph unicode="q" d="M63 481q0 111 31 204t89.5 158.5t145.5 102.5t197 37q47 0 99.5 -4t101.5 -11t93 -16.5t77 -19.5v-1270h-252v365q-47 -23 -99 -36.5t-100 -13.5q-94 0 -165.5 36t-119.5 101.5t-73 158.5t-25 208zM319 473q0 -133 44.5 -205.5t134.5 -72.5q43 0 80.5 10t66.5 26v529 q-18 2 -50 5t-67 3q-104 0 -156.5 -83t-52.5 -212z" />
<glyph unicode="r" d="M182 0v899q100 37 206 59.5t247 22.5q20 0 58 -2t81 -7t87 -12.5t79 -19.5l-45 -233q-25 6 -58.5 12t-68.5 11t-67.5 7t-55.5 2q-53 0 -104.5 -5t-104.5 -19v-715h-254z" />
<glyph unicode="s" d="M111 57l39 211q72 -29 152.5 -53.5t164.5 -24.5q92 0 141 13.5t49 54.5q0 27 -15 45.5t-43 31.5t-63 25l-75 25q-55 16 -112.5 37.5t-104.5 54.5t-78 83t-31 126q0 61 23.5 115.5t74 96.5t128 65.5t186.5 23.5q94 0 175 -14.5t140 -40.5l-39 -213q-35 10 -108.5 33.5 t-165.5 23.5q-96 0 -130 -23.5t-34 -50.5q0 -23 15.5 -40t41 -31.5t59.5 -27.5t72 -25q55 -18 115 -41t108 -57t78.5 -86t30.5 -128q0 -59 -22.5 -112.5t-74.5 -92t-136 -61.5t-207 -23q-125 0 -213 28.5t-141 51.5z" />
<glyph unicode="t" d="M74 754v209h219v241l252 41v-282h403v-209h-403v-389q0 -53 10 -86t28.5 -51.5t45 -24.5t59.5 -6q35 0 64.5 2t57.5 7t57.5 15t64.5 27l35 -217q-70 -29 -151 -41.5t-157 -12.5q-88 0 -155.5 14.5t-114.5 55.5t-71.5 116t-24.5 195v396h-219z" />
<glyph unicode="u" d="M121 426v537h252v-504q0 -133 31.5 -197.5t123.5 -64.5q57 0 115 10v756h254v-930q-70 -18 -169 -37t-216 -19q-119 0 -194.5 33t-119.5 93.5t-60.5 142.5t-16.5 180z" />
<glyph unicode="v" d="M29 963h264q18 -78 43.5 -166t54.5 -177l59 -174l56 -153l59 153l65 174l61 177q30 88 48 166h256q-86 -291 -190.5 -536t-196.5 -427h-211q-92 182 -187 427t-181 536z" />
<glyph unicode="w" d="M23 963h215q8 -178 17 -348.5t34 -350.5q27 78 46 144.5l35 127.5l28 116l28 116h182q12 -59 26 -116l29 -116l32 -127q17 -67 42 -145q12 94 20.5 180t13.5 171t8 170t7 178h215q-23 -281 -62.5 -529t-88.5 -434h-191l-42 117l-36 103l-35 105l-36 119l-37 -117 l-34 -104l-36 -104q-18 -53 -45 -119h-190q-25 90 -46.5 199.5t-40 233.5t-32.5 257.5t-26 272.5z" />
<glyph unicode="x" d="M41 0q31 57 71 120l84 127q44 65 92 128l93 121l-338 467h264l213 -301l197 301h256l-311 -463q49 -59 96 -126t90 -134.5t78 -129t59 -110.5h-262q-55 104 -110.5 186l-104.5 148q-61 -82 -110.5 -160t-100.5 -174h-256z" />
<glyph unicode="y" d="M41 -307l47 211q41 -18 73 -25.5t68 -7.5q74 0 119 49t72 117q-90 180 -180 412.5t-164 513.5h262q18 -76 41.5 -162t50.5 -172t56.5 -169t60.5 -155l43 155q23 83 43 168l40 171l36 164h258l-75 -266q-36 -130 -75 -254t-83 -242.5t-95 -231.5q-39 -82 -77 -141t-84 -97 t-102.5 -56.5t-131.5 -18.5q-63 0 -115.5 10.5t-87.5 26.5z" />
<glyph unicode="z" d="M137 0v154q47 78 103 159l110 161l109 151l96 129h-397v209h714v-185l-81 -97l-116 -144l-125 -167l-112 -161h455v-209h-756z" />
<glyph unicode="{" d="M129 449v196h111q63 0 89.5 44t26.5 128v303q0 152 71 232t255 80h213v-197h-190q-66 0 -90.5 -38t-24.5 -126v-231q0 -131 -48 -201t-159 -94q111 -20 159 -90t48 -201v-231q0 -86 24.5 -125t90.5 -39h190v-197h-213q-184 0 -255 80t-71 231v301q0 86 -26.5 130.5 t-89.5 44.5h-111z" />
<glyph unicode="|" d="M387 -338v1770h254v-1770h-254z" />
<glyph unicode="}" d="M129 -141h188q66 0 90.5 37.5t24.5 126.5v231q0 131 49 200.5t160 94.5q-111 20 -160 90t-49 201v231q0 86 -24.5 125t-90.5 39h-188v197h211q92 0 154.5 -20.5t100.5 -59.5t54.5 -97.5t16.5 -134.5v-301q0 -86 26.5 -130t89.5 -44h113v-196h-113q-63 0 -89.5 -44.5 t-26.5 -128.5v-303q0 -76 -16.5 -134t-54.5 -97t-100.5 -59.5t-154.5 -20.5h-211v197z" />
<glyph unicode="~" d="M43 408q8 51 28.5 107t54.5 103.5t85 79t123 31.5q53 0 101 -21.5t93 -48t86 -48t82 -21.5q16 0 31.5 4t30 18.5t28 41t25.5 71.5l186 -51q-10 -51 -29.5 -107.5t-54 -104.5t-85 -80t-121.5 -32q-55 0 -103.5 21.5t-93.5 48t-87 48t-81 21.5q-16 0 -31.5 -4t-30 -17 t-26.5 -40t-25 -72z" />
<glyph unicode="&#xa0;" />
<glyph unicode="&#xa2;" d="M94 537q0 174 91 300t288 167v262h254v-252q49 -4 95 -16.5t93 -30.5l-53 -213q-39 14 -87 25.5t-122 11.5q-170 0 -235.5 -64.5t-65.5 -189.5q0 -123 71 -188.5t241 -65.5q59 0 120.5 8t112.5 24l35 -217q-39 -16 -90 -26.5t-115 -14.5v-256h-254v267q-98 18 -170 61 t-118 104.5t-68.5 139.5t-22.5 164z" />
<glyph unicode="&#xa3;" d="M78 504v207h158v106q0 137 29.5 228.5t82.5 146.5t130 77.5t173 22.5q72 0 136.5 -14t125.5 -41l-67 -201q-43 23 -80 31t-90 10q-43 0 -80 -9t-62.5 -34.5t-40 -68.5t-14.5 -111v-143h303v-207h-303q0 -33 -2 -72t-5 -79t-7 -76.5t-10 -67.5h477v-209h-754 q33 147 43 273t15 231h-158z" />
<glyph unicode="&#xa5;" d="M27 1268h270q43 -131 95 -264.5t126 -280.5q145 291 221 545h260l-53 -132l-66 -151q-36 -78 -76 -155l-79 -146h193v-172h-277v-127h277v-172h-277v-213h-254v213h-278v172h278v127h-278v172h206l-81 146l-80 154l-73 150q-34 73 -54 134z" />
<glyph unicode="&#xa9;" d="M51 473q0 125 39 219t103.5 156.5t147.5 93.5t173 31q88 0 172 -31t148.5 -93.5t103.5 -156.5t39 -219t-39 -218t-103.5 -155.5t-148.5 -94.5t-172 -32q-90 0 -173 32t-147.5 94.5t-103.5 155.5t-39 218zM188 475q0 -90 28 -159.5t74 -116.5t103.5 -71t118.5 -24 t118.5 24t103.5 71t74 116.5t28 159.5q0 88 -28 156.5t-73 116t-103.5 72t-119.5 24.5t-118.5 -24.5t-103.5 -72t-74 -116t-28 -156.5zM291 469q0 49 14 96t43 84t73 59.5t105 22.5q33 0 69 -5t71 -21l-41 -111q-23 10 -45.5 13t-40.5 3q-66 0 -93.5 -41t-27.5 -92 q0 -66 33.5 -103.5t95.5 -37.5q18 0 41.5 4t46.5 14l35 -108q-35 -16 -73 -24.5t-73 -8.5q-59 0 -103 21.5t-73 57.5t-43 82t-14 95z" />
<glyph unicode="&#xad;" d="M231 401v248h562v-248h-562z" />
<glyph unicode="&#xae;" d="M51 473q0 125 39 219t103.5 156.5t147.5 93.5t173 31q88 0 172 -31t148.5 -93.5t103.5 -156.5t39 -219t-39 -218t-103.5 -155.5t-148.5 -94.5t-172 -32q-90 0 -173 32t-147.5 94.5t-103.5 155.5t-39 218zM188 475q0 -90 28 -159.5t74 -116.5t103.5 -71t118.5 -24 t118.5 24t103.5 71t74 116.5t28 159.5q0 88 -28 156.5t-73 116t-103.5 72t-119.5 24.5t-118.5 -24.5t-103.5 -72t-74 -116t-28 -156.5zM340 225v488q29 8 63.5 13t73.5 5q117 0 173.5 -45t56.5 -131q0 -98 -82 -145q25 -35 51 -83l53 -102h-117l-47 87q-20 38 -41 71h-73 v-158h-111zM451 485h36q55 0 82 14.5t27 61.5q0 41 -33 54.5t-67 13.5q-12 0 -23.5 -1t-21.5 -3v-140z" />
<glyph unicode="&#xb4;" d="M311 1188l324 227l125 -192l-357 -172z" />
<glyph unicode="&#x2000;" horiz-adv-x="751" />
<glyph unicode="&#x2001;" horiz-adv-x="1505" />
<glyph unicode="&#x2002;" horiz-adv-x="751" />
<glyph unicode="&#x2003;" horiz-adv-x="1505" />
<glyph unicode="&#x2004;" horiz-adv-x="501" />
<glyph unicode="&#x2005;" horiz-adv-x="374" />
<glyph unicode="&#x2006;" horiz-adv-x="249" />
<glyph unicode="&#x2007;" horiz-adv-x="249" />
<glyph unicode="&#x2008;" horiz-adv-x="186" />
<glyph unicode="&#x2009;" horiz-adv-x="301" />
<glyph unicode="&#x200a;" horiz-adv-x="81" />
<glyph unicode="&#x2010;" d="M231 401v248h562v-248h-562z" />
<glyph unicode="&#x2011;" d="M231 401v248h562v-248h-562z" />
<glyph unicode="&#x2012;" d="M231 401v248h562v-248h-562z" />
<glyph unicode="&#x2013;" d="M111 453v188h804v-188h-804z" />
<glyph unicode="&#x2014;" d="M0 453v188h1024v-188h-1024z" />
<glyph unicode="&#x2018;" d="M295 1030q0 70 22.5 142.5t72.5 134t130 106.5t195 60l33 -164q-37 -6 -74 -13.5t-71 -19.5t-61.5 -34.5t-43.5 -61.5q78 -6 121 -60.5t43 -120.5q0 -80 -52.5 -131t-132.5 -51q-86 0 -134 57.5t-48 155.5z" />
<glyph unicode="&#x2019;" d="M295 1014q37 8 75 14t71.5 18.5t60 35t43.5 61.5q-78 8 -121 61t-43 119q0 80 52 131t132 51q86 0 134.5 -57t48.5 -156q0 -72 -23 -143.5t-73 -133t-130 -106.5t-194 -59z" />
<glyph unicode="&#x201c;" d="M84 1026q0 59 24.5 125t71.5 121t119 94t166 45l37 -137l-77 -17q-38 -8 -70.5 -21t-58.5 -36.5t-40 -62.5q70 -4 102.5 -48.5t32.5 -97.5q0 -72 -47 -108.5t-102 -36.5q-80 0 -119 53t-39 127zM567 1026q0 59 24.5 125t72 121t119 94t165.5 45l35 -137l-76 -17 q-37 -8 -69.5 -21t-58 -36.5t-40.5 -62.5q68 -4 101.5 -48.5t33.5 -97.5q0 -72 -47 -108.5t-102 -36.5q-80 0 -119 53t-39 127z" />
<glyph unicode="&#x201d;" d="M59 1051l77 16q38 8 71 21.5t58.5 37t39.5 62.5q-70 4 -102.5 48t-32.5 97q0 72 47 109t102 37q80 0 119 -53.5t39 -127.5q0 -59 -24.5 -124.5t-71.5 -121t-119 -93t-166 -44.5zM543 1051l77 16q38 8 70.5 21.5t58 37t39.5 62.5q-70 4 -102.5 48t-32.5 97q0 72 46 109 t104 37q80 0 119 -53.5t39 -127.5q0 -59 -25 -124.5t-73 -121t-118.5 -93t-164.5 -44.5z" />
<glyph unicode="&#x2022;" d="M233 643q0 57 19.5 110.5t55.5 94.5t87 64.5t117 23.5q63 0 115.5 -23.5t88.5 -64.5t55.5 -94.5t19.5 -110.5q0 -59 -19.5 -111.5t-55.5 -93.5t-88.5 -64.5t-115.5 -23.5q-66 0 -117 23.5t-87 64.5t-55.5 93.5t-19.5 111.5z" />
<glyph unicode="&#x2026;" d="M57 110.5q0 51.5 30 92.5t89 41q55 0 87 -42t32 -91q0 -51 -31 -93.5t-88 -42.5q-59 0 -89 42t-30 93.5zM397 110.5q0 51.5 30 92.5t89 41q55 0 87 -42t32 -91q0 -51 -31 -93.5t-88 -42.5q-59 0 -89 42t-30 93.5zM735 110.5q0 51.5 31 92.5t88 41t88 -42t31 -91 q0 -51 -30 -93.5t-89 -42.5q-57 0 -88 42t-31 93.5z" />
<glyph unicode="&#x202f;" horiz-adv-x="301" />
<glyph unicode="&#x205f;" horiz-adv-x="374" />
<glyph unicode="&#x20ac;" d="M63 401v172h117v129h-117v172h142q47 211 174 314.5t309 103.5q59 0 125 -8t135 -37l-55 -209q-37 16 -85 25.5t-108 9.5q-104 0 -157.5 -53t-75.5 -146h373l-35 -172h-363q-2 -16 -3 -31.5t-1 -31.5t1 -32.5t3 -33.5h340l-34 -172h-281q25 -109 86 -156.5t137 -47.5 q53 0 116.5 10t119.5 37l53 -203q-63 -31 -140 -48.5t-155 -17.5q-86 0 -166 24t-144.5 74t-110.5 131t-66 197h-134z" />
<glyph unicode="&#x2122;" d="M37 1165v103h381v-103h-131v-434h-119v434h-131zM457 731q6 102 12 178t13 137.5t14.5 113.5t17.5 108h111l90 -279l96 279h111q10 -55 17 -108.5t13 -115t11.5 -137.5t11.5 -176h-119q0 8 -1 53t-2 103.5t-3 120t-4 102.5l-86 -238h-92l-80 238q-4 -41 -6 -102.5 t-3 -120t-2.5 -103.5t-1.5 -53h-118z" />
<glyph unicode="&#xe000;" horiz-adv-x="965" d="M0 965h965v-965h-965v965z" />
</font>
</defs></svg>
Side by side

After

Width:  |  Height:  |  Size: 30 KiB

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-B-webfont.ttf Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-B-webfont.woff Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-BI-webfont.eot Executable file
View file

Binary file not shown.

146
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-BI-webfont.svg Executable file
View file

@ -0,0 +1,146 @@
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg">
<metadata>
This is a custom SVG webfont generated by Font Squirrel.
Copyright : Copyright 2011 Canonical Ltd Licensed under the Ubuntu Font Licence 10
Designer : Dalton Maag Ltd
Foundry : Dalton Maag Ltd
Foundry URL : httpwwwdaltonmaagcom
</metadata>
<defs>
<font id="UbuntuMonoBoldItalic" horiz-adv-x="1024" >
<font-face units-per-em="2048" ascent="1638" descent="-410" />
<missing-glyph horiz-adv-x="500" />
<glyph unicode=" " />
<glyph unicode="!" d="M338 129q0 43 15.5 78t41 59.5t59 37.5t68.5 13q66 0 109 -37.5t43 -113.5q0 -41 -15.5 -76t-41 -60.5t-58.5 -40t-70 -14.5q-63 0 -107 39t-44 115zM467 461q6 70 13 130t15.5 117.5t19.5 114t28 117.5l78 328h290l-82 -342q-18 -74 -34.5 -133.5t-35 -112.5l-38.5 -106 l-45 -113h-209z" />
<glyph unicode="&#x22;" d="M395 815q2 51 5 113.5t9.5 127t15.5 126t21 112.5l21 97h266l-31 -129q-10 -47 -28.5 -103.5t-41 -116l-46.5 -117.5l-47 -110h-144zM799 815q2 51 6 113.5t10 127t14.5 126t20.5 112.5l22 97h265l-29 -129q-10 -47 -28.5 -103.5t-41 -116t-47 -118t-49.5 -109.5h-143z " />
<glyph unicode="#" d="M66 0l124 313h-122l49 205h157l95 234h-195l49 204h228l124 312h205l-125 -312h170l125 312h205l-127 -312h133l-49 -204h-164l-94 -234h201l-49 -205h-234l-127 -313h-205l127 313h-172l-125 -313h-204zM479 518h170l94 234h-170z" />
<glyph unicode="$" d="M96 119l103 188q45 -29 120.5 -57.5t163.5 -28.5q41 0 83 5t76 20.5t54.5 44t20.5 76.5q0 33 -13.5 56t-36 42.5t-52 36l-62.5 33.5q-78 37 -129 75.5t-83 80.5t-45 90t-13 104q0 61 22.5 118.5t68.5 103.5t116.5 79t168.5 43l50 190h211l-50 -194q72 -16 131.5 -39 t96.5 -45l-101 -180q-51 35 -118.5 53t-133.5 18q-84 0 -145 -33.5t-61 -101.5q0 -51 34.5 -88t126.5 -82q51 -27 100.5 -57.5t87.5 -70.5t60.5 -92t22.5 -122q0 -168 -106.5 -258t-280.5 -107l-52 -219h-213l54 222q-96 14 -168 43.5t-109 52.5z" />
<glyph unicode="%" d="M8 0l1061 1268h182l-1058 -1268h-185zM188 864q0 63 16.5 139t52.5 140.5t94.5 108.5t142.5 44q78 0 128 -56t50 -148q0 -63 -16.5 -138t-52.5 -140.5t-94 -110t-142 -44.5q-78 0 -128.5 56.5t-50.5 148.5zM346 893q0 -47 15.5 -61.5t33.5 -14.5q31 0 52.5 30t37 69.5 t22.5 81.5t7 67q0 45 -16.5 59.5t-32.5 14.5q-31 0 -52.5 -30t-37 -70t-22.5 -80.5t-7 -65.5zM590 176q0 63 16.5 138t52 139.5t94 108.5t142.5 44q78 0 127 -56t49 -149q0 -63 -16.5 -138t-52 -139.5t-94 -108.5t-142.5 -44q-78 0 -127 56.5t-49 148.5zM745 203 q0 -45 16.5 -59.5t33.5 -14.5q31 0 53 28.5t37.5 68.5t22.5 82t7 67q0 47 -16 61.5t-35 14.5q-31 0 -52 -30t-36.5 -70t-23 -81.5t-7.5 -66.5z" />
<glyph unicode="&#x26;" d="M92 264q0 68 17.5 122t51.5 101.5t85 91.5t116 91l23 16q-27 49 -42 101.5t-15 105.5q0 92 29.5 166t82 127t125 81.5t156.5 28.5q133 0 198.5 -64.5t65.5 -178.5q0 -45 -13.5 -93.5t-49 -100.5t-97 -106.5t-157.5 -111.5l-11 -6l129 -193q33 49 56.5 110.5t44.5 127.5 l188 -23q-31 -131 -83 -222t-99 -156q27 -55 53.5 -124t48.5 -155h-231q-10 41 -17.5 64.5l-17.5 52.5q-78 -74 -165 -104.5t-179 -30.5q-76 0 -131 22.5t-91 60t-53.5 89t-17.5 110.5zM315 301q0 -53 34 -92t95 -39q53 0 109.5 28.5t95.5 71.5q-29 51 -79 126l-99 149 q-51 -29 -82 -60.5t-47 -64.5t-21.5 -63.5t-5.5 -55.5zM535 915q0 -47 8 -79.5t24 -65.5l17 8q115 57 156.5 125t41.5 121q0 35 -19.5 60.5t-66.5 25.5q-68 0 -114.5 -52.5t-46.5 -142.5z" />
<glyph unicode="'" d="M573 778q2 53 6.5 116.5t10.5 128t15 127t22 114.5l30 127h271l-39 -160q-25 -102 -73 -224t-95 -229h-148z" />
<glyph unicode="(" d="M279 322q0 186 55 355t153.5 313.5t231.5 262t287 201.5l92 -178q-137 -86 -245 -197.5t-182.5 -235.5t-114.5 -253t-40 -250q0 -156 47 -284t168 -255l-151 -149q-66 55 -121.5 130t-95 161t-62 182.5t-22.5 196.5z" />
<glyph unicode=")" d="M88 -170q137 86 244.5 197.5t182.5 235.5t115 253t40 250q0 156 -48.5 284t-166.5 255l151 149q66 -55 121 -130t95 -161t62.5 -182t22.5 -197q0 -188 -55 -356t-153.5 -312.5t-231.5 -262t-287 -201.5z" />
<glyph unicode="*" d="M252 881l76 223l59 -19q25 -8 55.5 -25.5t61.5 -37.5l60 -41q30 -20 50 -37q-10 25 -20 58.5t-18.5 70.5t-14.5 72t-6 59v64h238v-64q0 -25 -6.5 -59.5t-15.5 -71.5t-20 -71l-20 -58l50 35q30 20 63 39.5l63.5 36t55.5 24.5l59 21l74 -228l-62 -18q-25 -8 -59.5 -12 t-71.5 -7.5t-73 -3.5h-62q23 -14 51 -35l58 -45q29 -24 53 -48.5t39 -45.5l39 -51l-193 -139l-37 51q-14 20 -29.5 51t-29.5 67l-26.5 69.5t-18.5 60.5q-6 -25 -19 -59l-25 -70q-13 -35 -28.5 -65.5t-30.5 -51.5l-39 -51l-192 137l39 51q14 20 40 45l53 50q28 25 56 46 l50 36h-63q-36 0 -73 3t-71.5 9t-57.5 14z" />
<glyph unicode="+" d="M137 434l51 207h322l84 356h217l-84 -356h322l-52 -207h-321l-84 -356h-217l84 356h-322z" />
<glyph unicode="," d="M197 -147q43 2 86 11t80.5 26.5t65.5 40t38 53.5q-61 8 -97 48t-36 105q0 88 57.5 146.5t143.5 58.5q80 0 119.5 -48t39.5 -114q0 -90 -28.5 -174t-88 -151.5t-150.5 -111.5t-214 -52z" />
<glyph unicode="-" d="M285 401l59 248h561l-61 -248h-559z" />
<glyph unicode="." d="M334 139q0 45 16.5 82t44 63.5t63.5 42t72 15.5q72 0 118 -41t46 -121q0 -45 -16 -83t-44 -64.5t-63.5 -42t-72.5 -15.5q-72 0 -118 41t-46 123z" />
<glyph unicode="/" d="M-23 -338l947 1770h264l-946 -1770h-265z" />
<glyph unicode="0" d="M145 367q0 80 12.5 180t41 203.5t74.5 202t113 175t157 122.5t207 46q164 0 256 -106.5t92 -286.5q0 -80 -12.5 -180t-41 -203.5t-74.5 -202t-112.5 -175t-157 -123t-204.5 -46.5q-82 0 -146.5 28t-109.5 80t-70 124t-25 162zM379 381q0 -84 30.5 -140.5t108.5 -56.5 q57 0 105.5 34t87.5 90.5t67.5 129t48 151.5t28.5 156.5t9 143.5q0 84 -29.5 140t-107.5 56q-57 0 -106.5 -33.5t-88 -90t-67.5 -130t-48.5 -151.5t-28.5 -155.5t-9 -143.5zM510 612q0 45 14.5 79t35 56.5t45 34t44.5 11.5q51 0 72.5 -28t21.5 -67q0 -45 -14 -78.5 t-34.5 -55t-44 -33t-44.5 -11.5q-51 0 -73.5 26.5t-22.5 65.5z" />
<glyph unicode="1" d="M131 0l49 209h266l177 733q-70 -47 -150 -86t-133 -57l-59 205q55 18 117.5 46.5t126 63.5t123 74t106.5 80h198l-254 -1059h252l-49 -209h-770z" />
<glyph unicode="2" d="M84 0q12 109 48 194t91.5 154.5t127 130t157.5 121.5l150 112q62 48 101.5 88t58 76.5t18.5 77.5q0 55 -33 89t-106.5 34t-154.5 -31.5t-159 -91.5l-82 183q106 84 221 121.5t226 37.5q82 0 145 -23.5t106 -64.5t65.5 -94t22.5 -115q0 -90 -34.5 -163.5t-91 -136 t-130.5 -117.5l-151 -111q-119 -82 -187.5 -142.5t-103.5 -119.5h565l-49 -209h-821z" />
<glyph unicode="3" d="M61 61l86 197q57 -35 135 -57.5t160 -22.5q57 0 108.5 11.5t90.5 38t62.5 69.5t23.5 106q0 84 -64.5 123t-179.5 39h-84l52 199h104q41 0 87 9t86 32.5t65.5 61.5t25.5 96q0 61 -46 94t-118 33q-53 0 -118.5 -19.5t-130.5 -56.5l-64 184q86 45 181 71.5t177 26.5 q76 0 142.5 -17t117 -52t79 -87.5t28.5 -123.5q0 -113 -65.5 -203t-206.5 -145q94 -43 139 -116t45 -159q0 -76 -28.5 -150.5t-94 -135t-171 -97.5t-257.5 -37q-100 0 -191.5 20.5t-175.5 67.5z" />
<glyph unicode="4" d="M82 299l45 188q57 80 144 181l187 205l205.5 208t204.5 187h246l-184 -768h135l-49 -201h-135l-72 -299h-238l70 299h-559zM354 500h338l119 491q-115 -106 -237 -236t-220 -255z" />
<glyph unicode="5" d="M66 59l94 203q66 -41 137.5 -60.5t138.5 -19.5q291 0 291 221q0 92 -107.5 146.5t-355.5 58.5l113 339q53 165 94 321h666l-50 -209h-462q-20 -76 -43 -147.5t-41 -118.5q113 -10 194.5 -42t135 -81t80 -112.5t26.5 -133.5q0 -205 -135 -328t-400 -123q-98 0 -194 20.5 t-182 65.5z" />
<glyph unicode="6" d="M154 418q0 162 54 316.5t167.5 275t289 193.5t414.5 73q10 0 29.5 -1t30.5 -1l-29 -201q-107 0 -207 -14.5t-186 -51t-154.5 -104t-111.5 -174.5q66 39 136 54.5t122 15.5q68 0 126 -21.5t102 -63.5t69.5 -104.5t25.5 -146.5q0 -119 -39 -210t-104.5 -153.5t-152.5 -94.5 t-183 -32q-84 0 -157.5 29t-127 85t-84 139t-30.5 192zM393 414q0 -47 11.5 -90t34 -75t56 -50.5t80.5 -18.5q98 0 158 71t60 193q0 49 -14.5 81t-39 50.5t-56.5 26.5t-69 8q-49 0 -100 -12t-98 -31q-10 -37 -16.5 -74.5t-6.5 -78.5z" />
<glyph unicode="7" d="M242 0q37 137 105.5 284.5t152.5 288t177 264.5t181 216h-575l51 215h883l-46 -185q-72 -59 -167 -170.5t-191 -257t-180 -313.5t-133 -342h-258z" />
<glyph unicode="8" d="M127 283q0 59 16.5 109t51 96.5t90 90.5t133.5 93q-47 49 -80 104t-33 131q0 72 26.5 141.5t82 125t139.5 89t199 33.5q76 0 140 -21.5t111.5 -59t75 -92t27.5 -122.5q0 -41 -10.5 -85t-39 -90t-81.5 -93t-141 -90q68 -47 115.5 -110.5t47.5 -163.5q0 -82 -31.5 -154 t-93 -126t-152.5 -85t-210 -31q-66 0 -134.5 16.5t-123.5 52.5t-90 95.5t-35 145.5zM367 315q0 -72 50 -107.5t122 -35.5q43 0 81.5 13.5t68.5 38t47.5 60t17.5 78.5q0 78 -53.5 124t-131.5 87q-63 -31 -102 -62.5t-61.5 -64t-30.5 -65.5t-8 -66zM537 924q0 -66 40.5 -109 t98.5 -78q117 55 155.5 112.5t38.5 113.5q0 66 -39.5 99.5t-111.5 33.5q-86 0 -134 -49t-48 -123z" />
<glyph unicode="9" d="M113 -4l30 199q106 0 206 14t186 53t154.5 107.5t111.5 179.5q-66 -39 -137.5 -54.5t-124.5 -15.5q-68 0 -126.5 20.5t-102.5 62.5t-69.5 103.5t-25.5 145.5q0 119 39 210t104.5 152.5t152.5 92t183 30.5q84 0 158 -28.5t128 -85t85 -139t31 -191.5q0 -164 -54.5 -318.5 t-168 -274.5t-286.5 -193.5t-413 -73.5q-10 0 -29.5 1t-31.5 3zM455 829q0 -94 53 -128.5t127 -34.5q47 0 99 12t100 31q10 39 15 74.5t5 74.5q0 94 -44 160.5t-136 66.5q-98 0 -158.5 -63.5t-60.5 -192.5z" />
<glyph unicode=":" d="M334 139q0 45 16.5 82t44 63.5t63.5 42t72 15.5q72 0 118 -41t46 -121q0 -45 -16 -83t-44 -64.5t-63.5 -42t-72.5 -15.5q-72 0 -118 41t-46 123zM481 760q0 45 16.5 82t44 63.5t63.5 42t73 15.5q72 0 118 -41t46 -121q0 -45 -16.5 -83t-44 -64.5t-63.5 -42t-73 -15.5 q-72 0 -118 41t-46 123z" />
<glyph unicode=";" d="M197 -147q43 2 86 11t80.5 26.5t65.5 40t38 53.5q-61 8 -97 48t-36 105q0 88 57.5 146.5t143.5 58.5q80 0 119.5 -48t39.5 -114q0 -90 -28.5 -174t-88 -151.5t-150.5 -111.5t-214 -52zM481 760q0 45 16.5 82t44 63.5t63.5 42t73 15.5q72 0 118 -41t46 -121 q0 -45 -16.5 -83t-44 -64.5t-63.5 -42t-73 -15.5q-72 0 -118 41t-46 123z" />
<glyph unicode="&#x3c;" d="M160 436l49 203l866 332l19 -226l-635 -221l522 -239l-104 -195z" />
<glyph unicode="=" d="M92 233l49 209h860l-49 -209h-860zM186 633l52 209h858l-49 -209h-861z" />
<glyph unicode="&#x3e;" d="M109 315l634 222l-522 239l105 195l716 -346l-49 -203l-866 -332z" />
<glyph unicode="?" d="M315 129q0 43 15.5 78t41 59.5t59.5 37.5t69 13q66 0 108.5 -37.5t42.5 -113.5q0 -41 -15 -76t-41 -60.5t-58.5 -40t-69.5 -14.5q-63 0 -107.5 39t-44.5 115zM393 1202q84 45 174 69.5t189 24.5q90 0 152.5 -20.5t102.5 -56t58 -82.5t18 -103q0 -61 -18 -109t-50 -89 t-75 -77t-94 -71l-80 -59q-33 -25 -56.5 -49.5t-40 -52t-28.5 -66.5h-233q14 94 64 165.5t165 153.5l83 63q34 26 53.5 48t28.5 46t9 54q0 94 -129 94q-68 0 -125 -21.5t-137 -55.5z" />
<glyph unicode="@" d="M113 301q0 215 50 397.5t140 315.5t214 207.5t274 74.5q184 0 270 -80.5t86 -232.5q0 -39 -7 -87t-18 -93l-166 -690q-57 -18 -118.5 -29.5t-114.5 -11.5q-66 0 -120 17.5t-93 56t-60.5 100t-21.5 149.5q0 94 24.5 186.5t75 164t125 116.5t172.5 45q35 0 62.5 -6 t42.5 -10q6 23 10 48.5t4 41.5q0 63 -44 101t-120 38q-96 0 -183 -54t-152.5 -157.5t-103.5 -251t-38 -331.5q0 -227 90 -325.5t248 -98.5q88 0 140.5 11t68.5 15l-14 -176q-53 -12 -108.5 -20t-115.5 -8q-242 0 -370.5 141t-128.5 436zM633 397q0 -66 28.5 -98.5 t81.5 -32.5h18q11 0 19 4l103 428q-16 12 -52 13q-53 0 -91 -28t-61.5 -73t-34.5 -100.5t-11 -112.5z" />
<glyph unicode="A" d="M-12 0q174 381 335.5 699.5t315.5 568.5h268q29 -242 46.5 -511.5t21.5 -574.5v-182h-254l8 295h-360l-64 -143q-33 -74 -61 -152h-256zM463 498h270q1 70 2 127q0 29 -1 55q-1 78 -3 138.5t-5 110.5t-5 99l-52 -100l-56 -110l-66 -138z" />
<glyph unicode="B" d="M80 27l293 1216q41 10 87 17.5t90 12.5t85 7t72 2q88 0 159.5 -16.5t122.5 -53t80 -93t29 -136.5q0 -92 -50.5 -177t-181.5 -136q86 -41 125 -101.5t39 -150.5q0 -98 -39 -178t-115.5 -136.5t-190.5 -88t-261 -31.5q-31 0 -73 2t-89 7t-95 13.5t-87 20.5zM369 207 q23 -4 58.5 -6t86.5 -2q37 0 84 10t88 34.5t69.5 67.5t28.5 109q0 82 -55 109.5t-143 27.5h-133zM504 760h78q51 0 100 9t88 31.5t63.5 59.5t24.5 90q0 66 -45 92.5t-125 26.5q-33 0 -62.5 -1t-52.5 -5z" />
<glyph unicode="C" d="M180 420q0 154 42 310.5t126 282.5t212 204.5t300 78.5q66 0 117 -12t90 -27.5t63.5 -33t34.5 -25.5l-94 -194q-41 31 -96 52t-141 21q-100 0 -175 -59.5t-125.5 -151.5t-75 -203.5t-24.5 -218.5q0 -55 11.5 -100t37 -79t67.5 -52t103 -18q94 0 157.5 22.5t104.5 46.5 l29 -203q-53 -33 -145 -60.5t-209 -27.5q-104 0 -182 32t-128.5 90.5t-75 141.5t-24.5 183z" />
<glyph unicode="D" d="M63 14l300 1237q90 18 152.5 24.5t127.5 6.5q205 0 322.5 -115.5t117.5 -328.5q0 -164 -38.5 -318.5t-124.5 -273.5t-222.5 -190.5t-328.5 -71.5q-66 0 -150 7t-156 23zM362 205q10 -2 23 -2h23q117 0 197.5 60.5t129.5 153.5t71.5 203.5t22.5 208.5q0 49 -8 92.5 t-28.5 75t-57.5 49t-94 17.5q-37 0 -74 -6z" />
<glyph unicode="E" d="M109 0l303 1268h751l-49 -209h-500l-69 -285h434l-49 -209h-434l-86 -356h544l-49 -209h-796z" />
<glyph unicode="F" d="M117 0l303 1268h778l-49 -209h-524l-76 -307h459l-50 -209h-458l-131 -543h-252z" />
<glyph unicode="G" d="M160 420q0 154 44 310.5t131 282.5t218 204.5t307 78.5q66 0 117 -12t90 -27.5t63.5 -33t34.5 -25.5l-94 -194q-41 31 -96 52t-141 21q-104 0 -183.5 -59.5t-132.5 -151.5t-79.5 -203.5t-26.5 -218.5q0 -111 41 -181t139 -70q27 0 52.5 2t47.5 6l111 463h252l-152 -633 q-47 -16 -146.5 -37t-217.5 -21q-190 0 -284.5 117t-94.5 330z" />
<glyph unicode="H" d="M53 0l305 1268h252l-121 -500h338l121 500h252l-305 -1268h-254l137 559h-338l-135 -559h-252z" />
<glyph unicode="I" d="M72 0l49 209h278l205 850h-278l49 209h805l-50 -209h-274l-205 -850h275l-49 -209h-805z" />
<glyph unicode="J" d="M76 113l129 182q41 -37 97 -69.5t128 -32.5q98 0 162.5 52t99.5 193l148 621h-410l49 209h662l-201 -844q-23 -96 -57.5 -179t-92 -143.5t-144.5 -94.5t-212 -34q-66 0 -122 13.5t-100 34t-78.5 45t-57.5 47.5z" />
<glyph unicode="K" d="M63 0l304 1268h254l-127 -527q63 57 127.5 126t123.5 140l112 138q52 68 89 123h289l-107 -140q-59 -76 -128.5 -156.5t-147.5 -160.5t-160 -152q49 -61 94 -138t83 -164t68 -178t48 -179h-264q-14 72 -42 155t-63.5 162.5t-76.5 150.5t-82 120l-142 -588h-252z" />
<glyph unicode="L" d="M92 0l303 1268h252l-254 -1059h535l-49 -209h-787z" />
<glyph unicode="M" d="M12 0l89 324l94 334l93 323q46 156 91 287h217l11 -114q7 -71 13.5 -151.5t11.5 -166.5l9 -160l307 592h232q-41 -309 -104 -624l-134 -644h-231l254 995l-283 -546h-178q-4 135 -13.5 274t-19.5 262l-227 -985h-232z" />
<glyph unicode="N" d="M53 0l303 1268h215l61 -197q32 -106 59.5 -214.5t51 -215t37.5 -195.5l195 822h223l-303 -1268h-205q-35 211 -83 432t-113 477l-218 -909h-223z" />
<glyph unicode="O" d="M137 367q0 80 12.5 180t42 203.5t75.5 202t115 175t160 122.5t210 46q166 0 260 -107.5t94 -285.5q0 -80 -12.5 -180t-41 -203.5t-75.5 -202t-114.5 -175t-159 -123t-209.5 -46.5q-168 0 -262.5 108t-94.5 286zM389 385q0 -80 27.5 -136t105.5 -56q84 0 146.5 71.5 t103.5 177t61.5 225t20.5 218.5q0 80 -27.5 136t-103.5 56q-84 0 -147.5 -71.5t-104.5 -177t-61.5 -226.5t-20.5 -217z" />
<glyph unicode="P" d="M78 0l301 1251q96 16 181 23.5t151 7.5q113 0 193.5 -25.5t133 -72.5t76 -111.5t23.5 -140.5q0 -129 -48.5 -224.5t-134.5 -157t-204.5 -91t-262.5 -29.5h-53l-104 -430h-252zM485 647h62q166 0 251 65.5t85 182.5q0 78 -43 123t-162 45q-29 0 -47.5 -1t-46.5 -5z" />
<glyph unicode="Q" d="M139 367q0 80 12.5 180t41 203.5t75.5 202t115 175t159 122.5t210 46q166 0 259 -107.5t93 -285.5q0 -76 -11.5 -170t-36 -192.5t-66.5 -193.5t-101.5 -173t-140 -130t-185.5 -67v-14q0 -59 83 -94t206 -49l-78 -168q-205 29 -308.5 99.5t-103.5 205.5v16q0 8 3 19 q-109 39 -167.5 136.5t-58.5 238.5zM389 385q0 -80 27.5 -136t105.5 -56q84 0 146.5 71.5t103.5 177t61.5 225t20.5 218.5q0 80 -27.5 136t-103.5 56q-84 0 -147.5 -71.5t-104.5 -177t-61.5 -226.5t-20.5 -217z" />
<glyph unicode="R" d="M70 0l297 1247q39 8 83 15.5t87 11.5t81.5 6t69.5 2q203 0 303.5 -89t100.5 -241q0 -72 -19.5 -140.5t-59.5 -126.5t-98.5 -102t-134.5 -65q31 -51 58.5 -114.5t52 -132t44 -138.5t32.5 -133h-246q-23 123 -64 237.5t-96 229.5h-131l-113 -467h-247zM479 676h94 q53 0 101.5 14.5t85.5 45t58.5 77.5t21.5 111q0 72 -43 110.5t-148 38.5q-23 0 -41 -2t-35 -6z" />
<glyph unicode="S" d="M63 84l109 192q20 -12 52 -28.5t72 -30.5t87 -23.5t100 -9.5q47 0 90 9.5t75 31t51.5 54t19.5 81.5q0 37 -15.5 67t-42 54.5t-62.5 45t-77 40.5q-51 27 -95 53.5t-76 63.5t-50 88t-18 125q0 180 121.5 289.5t347.5 109.5q74 0 132 -10t103 -24.5t77 -31t52 -28.5 l-106 -194q-47 33 -119 55t-172 22q-78 0 -132.5 -34.5t-54.5 -120.5q0 -70 46.5 -106t111.5 -64q61 -29 112.5 -59.5t88.5 -71.5t58.5 -96.5t21.5 -131.5q0 -209 -134.5 -318.5t-379.5 -109.5q-82 0 -146.5 12.5t-111.5 29t-81.5 36t-54.5 33.5z" />
<glyph unicode="T" d="M264 1059l49 209h922l-49 -209h-336l-254 -1059h-252l254 1059h-334z" />
<glyph unicode="U" d="M137 299q0 84 25 188l188 781h252l-186 -779l-18.5 -89t-8.5 -76q0 -61 28.5 -96t104.5 -35q45 0 78 13t57.5 45t44 85t37.5 133l193 799h252l-197 -817q-27 -113 -60.5 -201t-89 -149.5t-140.5 -94.5t-212 -33q-180 0 -264 86t-84 240z" />
<glyph unicode="V" d="M279 1153v61q0 29 2 54h258q-4 -96 -6.5 -220t-2.5 -257q0 -143 3.5 -280.5t9.5 -254.5l120 242l127 273l117 268l94 229h263l-124 -275l-154 -318l-177 -340q-94 -173 -193 -335h-268q-16 119 -28.5 261t-21.5 293t-14 304.5t-5 294.5z" />
<glyph unicode="W" d="M80 0q41 309 103 624l134 644h232l-252 -996l281 547h178q4 -135 14 -274t21 -262l227 985h229l-88 -324l-92 -335l-94 -322q-47 -156 -92 -287h-217l-12 114q-7 71 -13 151l-12 166q-6 85 -8 159l-306 -590h-233z" />
<glyph unicode="X" d="M4 0l528 692l-225 576h258l140 -387l140 187q73 99 138 200h266q-111 -158 -225 -303l-231 -289q33 -88 63.5 -184.5t54 -187.5t40 -170t22.5 -134h-250q-14 104 -40 228t-60 239l-330 -467h-289z" />
<glyph unicode="Y" d="M291 1268h248q12 -147 39.5 -296t58.5 -276l80 118l96 150l97 158l85 146h271l-126 -203l-128 -195q-66 -96 -139 -191l-154 -196l-117 -483h-252l115 481q-63 199 -104 388.5t-70 398.5z" />
<glyph unicode="Z" d="M57 0l41 166l136 180l162 202l199 234l245 279h-512l51 207h790l-49 -205l-219 -248l-188 -218l-168 -200l-156 -190h551l-51 -207h-832z" />
<glyph unicode="[" d="M182 -338l426 1770h570l-48 -197h-327l-332 -1376h328l-47 -197h-570z" />
<glyph unicode="\" d="M422 1432h240l165 -1770h-243z" />
<glyph unicode="]" d="M31 -338l47 197h328l331 1376h-327l47 197h569l-426 -1770h-569z" />
<glyph unicode="^" d="M158 651l514 617h213l215 -641l-230 -99l-149 463l-373 -454z" />
<glyph unicode="_" d="M-70 -338l54 219h915l-53 -219h-916z" />
<glyph unicode="`" d="M487 1223l125 192l324 -241l-92 -138z" />
<glyph unicode="a" d="M131 352q0 139 47 256t129 200t191.5 129t232.5 46q84 0 170 -16.5t174 -51.5l-127 -522q-8 -37 -12 -72.5t-4 -72.5q0 -59 11 -115.5t30 -112.5l-221 -36l-11 20q-6 12 -12 26.5t-10 26l-6 17.5q-41 -31 -111 -64t-180 -33q-135 2 -213 97.5t-78 277.5zM381 373 q0 -53 9 -88t26.5 -55.5t42 -28.5t55.5 -8q57 0 96 25.5t68 60.5l8 55q4 27 12 61l88 365q-23 6 -47 8t-47 2q-72 0 -129 -34t-98 -89t-62.5 -126.5t-21.5 -147.5z" />
<glyph unicode="b" d="M82 35l324 1343l262 43l-117 -487q43 23 91 35t93 12q135 0 214 -91t79 -286q0 -139 -43 -256t-121 -199.5t-186.5 -129t-239.5 -46.5q-82 0 -180 16.5t-176 45.5zM373 199q23 -4 47 -6.5t47 -2.5q76 0 133 33t97 87.5t60.5 125t20.5 148.5q0 106 -35.5 146t-95.5 40 q-33 0 -75 -12.5t-70 -34.5z" />
<glyph unicode="c" d="M158 373q0 133 47 245.5t132 193.5t201.5 127t258.5 46q55 0 97 -4t77 -11t62.5 -16.5t53.5 -21.5l-90 -201q-33 14 -84 25.5t-116 11.5q-84 0 -154 -25.5t-122 -75t-80.5 -121t-28.5 -163.5q0 -41 10 -75t37.5 -58.5t76 -38.5t121.5 -14q80 0 148.5 15t103.5 32l25 -201 l-53.5 -24.5t-67.5 -21.5t-91 -14.5t-124 -5.5q-125 0 -209 32t-135 85t-73.5 126t-22.5 153z" />
<glyph unicode="d" d="M131 352q0 139 47 255t128 198t190.5 127t232.5 45q55 0 107 -14l98 415l262 43l-248 -1028q-8 -37 -12 -72.5t-4 -72.5q0 -59 11 -115.5t30 -112.5l-221 -36l-11 20q-6 12 -12 26.5t-10 26l-6 17.5q-41 -31 -111 -64t-180 -33q-135 2 -213 97.5t-78 277.5zM381 373 q0 -53 9 -88t26.5 -55.5t42 -28.5t55.5 -8q57 0 96 25.5t68 60.5l8 55q4 27 12 61l88 365q-23 6 -47 8t-47 2q-72 0 -129 -34t-98 -89t-62.5 -126.5t-21.5 -147.5z" />
<glyph unicode="e" d="M154 375q0 119 39.5 230.5t116.5 195.5t186.5 135t251 51t231.5 -69.5t90 -194.5q0 -104 -51 -177t-141.5 -118t-212 -65.5t-263.5 -20.5q0 -37 12.5 -66.5t40 -50t73.5 -32t116 -11.5q82 0 155.5 17.5t108.5 33.5l17 -190q-49 -25 -137.5 -46.5t-192.5 -21.5 q-117 0 -201 30t-137 83t-77.5 126t-24.5 161zM403 516q129 0 212 16.5t130.5 42t65.5 56.5t18 57q0 47 -33.5 72.5t-95.5 25.5q-94 0 -179 -64.5t-118 -205.5z" />
<glyph unicode="f" d="M-72 -303l70 213q27 -10 58.5 -17.5t72.5 -7.5q45 0 78 14.5t54.5 38t34.5 55.5t19 68l140 693h-207l51 209h199l10 55q25 117 69 193.5t104 122.5t134 65.5t156 19.5q66 0 126 -10t113 -35l-88 -205q-41 18 -76.5 26.5t-78.5 8.5q-37 0 -69 -5t-58.5 -24.5t-47 -56.5 t-32.5 -100l-10 -55h348l-51 -209h-338l-140 -701q-39 -193 -147.5 -295t-288.5 -102q-61 0 -112.5 11.5t-92.5 29.5z" />
<glyph unicode="g" d="M2 -264l88 198q53 -23 119.5 -43t155.5 -20q123 0 185 52t83 138l12 54q-45 -23 -92 -36t-90 -13q-164 0 -235.5 92t-71.5 243q0 139 50 248t134 182.5t191.5 112.5t222.5 39q86 0 173 -13.5t165 -45.5l-195 -811q-29 -119 -72 -205t-109.5 -142.5t-158.5 -83t-217 -26.5 q-109 0 -185.5 19.5t-152.5 60.5zM401 420q0 -61 27 -106.5t109 -45.5q29 0 72.5 11.5t84.5 37.5l109 449q-49 12 -94 12q-70 0 -126.5 -29.5t-96.5 -78.5t-62.5 -114.5t-22.5 -135.5z" />
<glyph unicode="h" d="M90 0l330 1378l262 43l-111 -463q35 10 72 17.5t72 7.5q152 0 227.5 -72.5t75.5 -205.5q0 -35 -5 -76t-16 -86l-131 -543h-252l123 510q6 33 14.5 67.5t8.5 69.5q0 47 -24.5 83t-94.5 36q-27 0 -58.5 -5t-60.5 -18l-180 -743h-252z" />
<glyph unicode="i" d="M227 754l52 209h518l-140 -588q-12 -43 -12 -76q0 -102 105 -102q35 0 82 7t104 27l4 -204q-76 -29 -142.5 -39.5t-123.5 -10.5q-145 0 -215 71t-70 200q0 68 23 158l82 348h-267zM535 1223q0 39 14 72.5t37.5 56t54.5 36t64 13.5q59 0 103 -35t44 -113 q0 -37 -15.5 -69.5t-40 -55t-55 -36t-61.5 -13.5q-66 0 -105.5 35t-39.5 109z" />
<glyph unicode="j" d="M-12 -256l98 203q45 -29 96 -51.5t117 -22.5q78 0 127 38t74 140l168 703h-389l51 209h641l-219 -912q-29 -117 -69 -194.5t-93 -122.5t-121 -63.5t-152 -18.5q-104 0 -190 25.5t-139 66.5zM664 1223q0 39 14 72.5t37.5 56t54.5 36t64 13.5q61 0 105 -35t44 -113 q0 -37 -15.5 -69.5t-40 -55t-55 -36t-61.5 -13.5q-66 0 -106.5 35t-40.5 109z" />
<glyph unicode="k" d="M111 0l331 1378l263 43l-199 -827q37 31 86 76l100 95q51 50 99.5 102.5t82.5 95.5h287q-98 -119 -221 -235t-233 -208q37 -45 74.5 -109.5t74.5 -136t67.5 -143.5t51.5 -131h-273q-16 51 -42.5 116.5t-57.5 131t-63.5 123t-63.5 94.5l-110 -465h-254z" />
<glyph unicode="l" d="M297 1200l49 209h518l-241 -1024l-10 -44q-5 -24 -5 -42q0 -41 22.5 -71.5t92.5 -30.5q29 0 58.5 5t56.5 13l47 14q20 6 30 11l17 -199l-32 -15q-24 -11 -62.5 -21.5t-91 -19t-115.5 -8.5q-139 0 -209 72t-70 201q0 35 5 72.5t16 78.5l190 799h-266z" />
<glyph unicode="m" d="M43 0l221 920q76 27 138.5 40t121.5 13q53 0 99.5 -16.5t74.5 -55.5q47 37 101.5 54.5t97.5 17.5q82 0 134 -50.5t52 -156.5q0 -25 -3 -52.5t-11 -56.5l-156 -657h-204l159 676q4 14 6.5 29.5t2.5 23.5q0 61 -56 62q-20 0 -38.5 -10.5t-34.5 -24.5q0 -47 -13 -99 l-69 -290h-199l72 305q4 12 8 28.5t4 32.5q0 20 -10.5 37.5t-40.5 17.5q-35 0 -66 -10l-186 -778h-205z" />
<glyph unicode="n" d="M90 0l221 922q63 20 166 40.5t219 20.5q172 0 247 -73.5t75 -204.5q0 -35 -5 -76t-16 -86l-133 -543h-252l125 510q6 33 14.5 67.5t8.5 69.5q0 47 -25.5 83t-93.5 36q-29 0 -59.5 -5t-59.5 -18l-180 -743h-252z" />
<glyph unicode="o" d="M133 334q0 123 37 239.5t108.5 208.5t178 148.5t245.5 56.5q150 0 241 -91t91 -271q0 -121 -34.5 -238t-105.5 -209t-176.5 -148.5t-244.5 -56.5q-172 0 -256 98.5t-84 262.5zM385 399q0 -96 27.5 -151t111.5 -55q61 0 108.5 36.5t81.5 92t51 120t17 121.5 q0 96 -27.5 151.5t-113.5 55.5q-59 0 -107.5 -37t-81 -92t-50 -120t-17.5 -122z" />
<glyph unicode="p" d="M-4 -338l303 1256q43 18 92 30.5t99.5 20.5t96.5 11t83 3q190 0 278 -97.5t88 -250.5q0 -127 -36.5 -246t-111.5 -210t-189.5 -145t-268.5 -54q-41 0 -63.5 2t-38.5 6l-80 -326h-252zM379 201q10 -4 22 -4h27q84 0 151.5 33.5t113.5 91t70.5 134t24.5 160.5q0 31 -6 60 t-22.5 51.5t-47 35.5t-79.5 13q-41 0 -68.5 -4t-50.5 -10z" />
<glyph unicode="q" d="M147 352q0 141 47.5 257t129.5 199t191.5 129t232.5 46q84 0 170 -16.5t174 -51.5l-301 -1253h-252l86 365q-90 -45 -187 -45q-133 0 -212 94t-79 276zM397 373q0 -53 9.5 -88t27 -55.5t42 -28.5t54.5 -8q33 0 75 13t71 36l127 518q-23 6 -47.5 8t-46.5 2 q-72 0 -129.5 -34t-98.5 -89t-62.5 -126.5t-21.5 -147.5z" />
<glyph unicode="r" d="M141 0l215 899q96 39 208 60.5t210 21.5q115 0 187.5 -10t134.5 -27l-97 -231q-39 14 -92 22t-131 8q-53 0 -109.5 -7t-103.5 -23l-170 -713h-252z" />
<glyph unicode="s" d="M100 63l95 199q41 -23 112.5 -49.5t171.5 -26.5q109 0 150 29t41 68q0 18 -7.5 32.5t-24.5 27.5t-48 26.5t-78 31.5q-57 20 -100 43t-72 52.5t-43 68.5t-14 92q0 150 105.5 240t316.5 90q104 0 191 -18.5t138 -42.5l-92 -199q-47 23 -107.5 37t-152.5 14q-20 0 -46 -3 t-48.5 -13t-37.5 -27.5t-15 -44.5q0 -18 5 -31.5t21.5 -27t47 -27.5t81.5 -33q61 -25 105.5 -49t74 -55t43 -72t13.5 -98q0 -59 -24.5 -116.5t-77 -103.5t-136.5 -75t-201 -29q-84 0 -147.5 10.5t-110.5 25t-79 29.5t-50 25z" />
<glyph unicode="t" d="M225 754l51 209h191l57 241l264 41l-69 -282h366l-51 -209h-364l-90 -375q-10 -51 -11 -80q0 -61 42 -81.5t96 -20.5q55 0 113.5 13t113.5 36l-2 -211q-63 -29 -140 -43.5t-153 -14.5q-164 0 -245 71t-81 206q0 33 4.5 66.5t14.5 72.5l86 361h-193z" />
<glyph unicode="u" d="M156 268q0 94 28 219l115 476h252l-109 -459q-16 -61 -24 -111.5t-8 -89.5q0 -106 102 -106q57 0 91 23.5t65 58.5q4 29 7 55t13 61l135 568h252l-137 -570q-8 -37 -13 -72.5t-5 -72.5q0 -59 12 -115.5t31 -112.5l-222 -36l-10 20q-6 12 -12 26.5t-10 26t-7 17.5 q-41 -31 -106.5 -64t-142.5 -33q-166 0 -231.5 78t-65.5 213z" />
<glyph unicode="v" d="M217 963h262q2 -74 6 -162t11.5 -177t16.5 -177.5t19 -161.5q43 61 92.5 146t95.5 178t85 185.5t61 168.5h271q-49 -131 -117 -269.5t-142.5 -266.5t-151.5 -238.5t-142 -188.5h-228q-47 186 -85 429t-54 534z" />
<glyph unicode="w" d="M131 0q0 90 4 199.5t13.5 233.5t23.5 257t37 273h219l-66 -350q-31 -171 -53 -361l84 151l68 132l57 117l53 116h166q4 -115 9.5 -233.5l13.5 -282.5l60 186q28 88 51 174l47 172l45 179h221q-90 -281 -179.5 -529t-187.5 -434h-188q-10 109 -17.5 220.5t-15.5 254.5 l-68 -136q-31 -60 -62 -114l-66 -107l-74 -118h-195z" />
<glyph unicode="x" d="M20 0l437 489l-234 474h264l142 -308l120.5 153t110.5 155h266q-78 -111 -170 -229t-213 -247q72 -135 124.5 -249.5t93.5 -237.5h-259q-33 86 -68 167l-67 144l-270 -311h-277z" />
<glyph unicode="y" d="M-88 -301l80 201q33 -14 61.5 -21.5t73.5 -7.5q150 0 248 147q-49 197 -89 427.5t-55 517.5h263q2 -74 7 -162t13 -178.5t19.5 -178.5t25.5 -159q94 143 166 310t131 368h268q-53 -141 -104 -262t-105.5 -230t-114 -208t-126.5 -195q-51 -74 -109.5 -147t-127 -132 t-150.5 -96t-178 -37q-127 0 -197 43z" />
<glyph unicode="z" d="M100 0l43 166l126 142l148 156l152 153l142 137h-416l51 209h739l-43 -185q-41 -35 -107 -97l-147 -139l-165 -163l-164 -170h461l-52 -209h-768z" />
<glyph unicode="{" d="M203 449l47 196h100q63 0 108.5 44t63.5 128l72 303q18 76 44 134.5t68 97.5t105 59.5t156 20.5h219l-49 -197h-154q-43 0 -70.5 -9t-46 -28.5t-31 -51.5t-22.5 -75l-61 -260q-29 -115 -83.5 -179.5t-162.5 -84.5q70 -31 94.5 -84t24.5 -115q0 -29 -3.5 -58.5 t-11.5 -58.5l-45 -202l-9 -45q-5 -25 -5 -45q0 -35 20.5 -57.5t73.5 -22.5h184l-47 -197h-190q-59 0 -109.5 12.5t-87.5 40t-58.5 73.5t-21.5 112q0 53 19 127l51 223q6 25 11 49.5t5 48.5q0 41 -21.5 71t-80.5 30h-96z" />
<glyph unicode="|" d="M256 -338l426 1770h252l-424 -1770h-254z" />
<glyph unicode="}" d="M8 -338l47 197h156q43 0 69.5 9t45 28.5t31 51.5t22.5 75l61 260q29 115 83.5 179t162.5 85q-70 31 -94.5 84t-24.5 114q0 29 4 59t11 58l45 203l9 45q5 25 5 45q0 35 -19.5 57.5t-74.5 22.5h-185l48 197h190q59 0 110.5 -12.5t88.5 -40t57.5 -73.5t20.5 -112 q0 -29 -4.5 -59.5t-12.5 -65.5l-53 -225q-6 -25 -10 -49.5t-4 -49.5q0 -41 20.5 -70.5t79.5 -29.5h96l-47 -196h-98q-63 0 -109.5 -44.5t-64.5 -128.5l-72 -303q-18 -76 -44 -134t-68 -97t-105.5 -59.5t-155.5 -20.5h-217z" />
<glyph unicode="~" d="M102 410q20 61 52 119.5t75 102.5t97.5 70.5t120 26.5t111.5 -25.5t87 -54.5q29 -20 62.5 -39.5t66.5 -19.5q20 0 36.5 4t32 18.5t32 41t38.5 71.5l172 -53q-25 -66 -57.5 -124.5t-74.5 -101.5t-95 -68.5t-118.5 -25.5t-111.5 26.5t-85 55.5q-31 20 -64 39t-67 19 q-20 0 -37 -4.5t-32 -17.5t-32.5 -40t-38.5 -72z" />
<glyph unicode="&#xa0;" />
<glyph unicode="&#xa2;" d="M180 442q0 115 36 211.5t101.5 169t156.5 119.5t202 62l63 264h252l-63 -269q53 -8 95 -22t77 -29l-92 -200q-31 14 -86.5 29.5t-120.5 15.5q-78 0 -145.5 -20.5t-117 -60.5t-77 -100.5t-27.5 -140.5q0 -92 58.5 -144.5t199.5 -52.5q80 0 139.5 17.5t94.5 34.5l24 -201 q-41 -23 -104.5 -41t-145.5 -25l-59 -258h-254l66 275q-76 16 -128.5 52t-84 85t-46 107.5t-14.5 121.5z" />
<glyph unicode="&#xa3;" d="M156 0q70 154 109.5 277.5t68.5 228.5h-162l49 211h164l47 188q27 106 76 181t113.5 121t140.5 66.5t153.5 20.5t149.5 -15t125 -50l-103 -191q-41 23 -85 33t-87 10t-79.5 -9t-68.5 -34.5t-56.5 -70.5t-42.5 -119l-33 -133h323l-49 -209h-323q-16 -66 -44 -145.5 l-55 -149.5h504l-49 -211h-786z" />
<glyph unicode="&#xa5;" d="M127 207l37 160h268l33 145h-266l39 160h217q-59 158 -110.5 315.5t-80.5 280.5h262q12 -61 24.5 -116.5t28 -114t35 -123l45.5 -144.5q182 219 340 498h273l-101 -155l-101 -143l-108 -144l-124 -154h200l-39 -160h-268l-33 -145h269l-39 -160h-271l-49 -207h-266 l51 207h-266z" />
<glyph unicode="&#xa9;" d="M129 473q0 125 39 219t102.5 156.5t146.5 93.5t173 31t173 -31t147.5 -93.5t103.5 -156.5t39 -219t-39 -218t-103.5 -155.5t-147.5 -94.5t-173 -32t-173 32t-146.5 94.5t-102.5 155.5t-39 218zM264 475q0 -90 27.5 -159.5t74 -116.5t104.5 -71t120 -24q59 0 117.5 24 t104.5 71t73.5 116.5t27.5 159.5q0 88 -27.5 156.5t-73.5 116t-103.5 72t-119 24.5t-119.5 -24.5t-104.5 -72t-74 -116t-27.5 -156.5zM367 469q0 49 14 96t43 84t74 59.5t106 22.5q31 0 67 -5t72 -21l-43 -111q-23 10 -44 13t-42 3q-63 0 -90.5 -41t-27.5 -92 q0 -66 32.5 -103.5t96.5 -37.5q16 0 40.5 4t45.5 14l34 -108q-35 -16 -72.5 -24.5t-70.5 -8.5q-59 0 -103 21.5t-74 57.5t-44 82t-14 95z" />
<glyph unicode="&#xad;" d="M285 401l59 248h561l-61 -248h-559z" />
<glyph unicode="&#xae;" d="M129 473q0 125 39 219t102.5 156.5t146.5 93.5t173 31t173 -31t147.5 -93.5t103.5 -156.5t39 -219t-39 -218t-103.5 -155.5t-147.5 -94.5t-173 -32t-173 32t-146.5 94.5t-102.5 155.5t-39 218zM264 475q0 -90 27.5 -159.5t74 -116.5t104.5 -71t120 -24q59 0 117.5 24 t104.5 71t73.5 116.5t27.5 159.5q0 88 -27.5 156.5t-73.5 116t-103.5 72t-119 24.5t-119.5 -24.5t-104.5 -72t-74 -116t-27.5 -156.5zM418 225v488q27 8 62.5 13t74.5 5q117 0 172 -45t55 -131q0 -100 -80 -145q23 -35 50.5 -83t54.5 -102h-117l-48 87l-40 71h-76v-158h-108 zM526 485h39q55 0 82 14.5t27 61.5q0 41 -33 54.5t-68 13.5q-14 0 -25 -1t-22 -3v-140z" />
<glyph unicode="&#xb4;" d="M565 1174l324 241l125 -192l-357 -187z" />
<glyph unicode="&#x2000;" horiz-adv-x="751" />
<glyph unicode="&#x2001;" horiz-adv-x="1505" />
<glyph unicode="&#x2002;" horiz-adv-x="751" />
<glyph unicode="&#x2003;" horiz-adv-x="1505" />
<glyph unicode="&#x2004;" horiz-adv-x="501" />
<glyph unicode="&#x2005;" horiz-adv-x="374" />
<glyph unicode="&#x2006;" horiz-adv-x="249" />
<glyph unicode="&#x2007;" horiz-adv-x="249" />
<glyph unicode="&#x2008;" horiz-adv-x="186" />
<glyph unicode="&#x2009;" horiz-adv-x="301" />
<glyph unicode="&#x200a;" horiz-adv-x="81" />
<glyph unicode="&#x2010;" d="M285 401l59 248h561l-61 -248h-559z" />
<glyph unicode="&#x2011;" d="M285 401l59 248h561l-61 -248h-559z" />
<glyph unicode="&#x2012;" d="M285 401l59 248h561l-61 -248h-559z" />
<glyph unicode="&#x2013;" d="M180 453l47 188h805l-47 -188h-805z" />
<glyph unicode="&#x2014;" d="M70 453l45 188h1024l-45 -188h-1024z" />
<glyph unicode="&#x2018;" d="M535 1051q0 76 28.5 153.5t88 141t149.5 107.5t215 52l16 -162q-43 -2 -87 -11t-82 -26.5t-65.5 -40t-37.5 -53.5q61 -8 98 -48t37 -105q0 -43 -15.5 -81t-43 -65.5t-64.5 -43t-80 -15.5q-80 0 -118.5 56.5t-38.5 140.5z" />
<glyph unicode="&#x2019;" d="M485 1016q43 2 86 11t81 26.5t65.5 40t38.5 53.5q-59 8 -96 48t-37 105q0 88 57 146.5t143 58.5q82 0 121 -56t39 -142q0 -76 -28.5 -153t-88 -140.5t-150.5 -107.5t-214 -52z" />
<glyph unicode="&#x201c;" d="M330 1034q0 68 24.5 134.5t74.5 119.5t128 88t186 43l15 -135q-37 -4 -75 -12t-69.5 -21.5t-55 -34t-32.5 -45.5q53 -6 85 -42.5t32 -92.5q0 -76 -50 -127t-124 -51q-72 0 -105.5 50t-33.5 126zM809 1034q0 68 23.5 134.5t74.5 119.5t128 88t186 43l14 -135 q-37 -4 -74 -12t-68.5 -21.5t-55 -34t-31.5 -45.5q53 -6 83.5 -42.5t30.5 -92.5q0 -76 -50 -127t-124 -51q-72 0 -104.5 50t-32.5 126z" />
<glyph unicode="&#x201d;" d="M272 993q37 2 74 10.5t68.5 21.5t55.5 33.5t32 45.5q-53 8 -85 45t-32 90q0 78 51 129t125 51q72 0 104.5 -51t32.5 -125q0 -68 -23.5 -134.5t-74.5 -119.5t-129 -88t-184 -43zM750 993q37 2 74.5 10.5t69.5 21.5t54.5 33.5t32.5 45.5q-53 8 -86 45t-33 90q0 78 51.5 129 t124.5 51q72 0 106 -51t34 -125q0 -68 -25 -134.5t-75 -119.5t-129 -88t-185 -43z" />
<glyph unicode="&#x2022;" d="M356 643q0 57 19.5 110.5t55.5 94.5t87 64.5t117 23.5q63 0 115.5 -23.5t88 -64.5t55 -94.5t19.5 -110.5q0 -59 -19.5 -111.5t-55 -93.5t-88 -64.5t-115.5 -23.5q-66 0 -117 23.5t-87 64.5t-55.5 93.5t-19.5 111.5z" />
<glyph unicode="&#x2026;" d="M51 90q0 70 39 111t92 41q49 0 80 -29t31 -84q0 -72 -39 -113t-92 -41q-51 0 -81 29t-30 86zM391 90q0 70 39 111t92 41q51 0 81 -29t30 -84q0 -72 -39 -113t-92 -41q-49 0 -80 29t-31 86zM729 90q0 70 40 111t93 41q49 0 79 -29t30 -84q0 -72 -39 -113t-92 -41 q-49 0 -80 29t-31 86z" />
<glyph unicode="&#x202f;" horiz-adv-x="301" />
<glyph unicode="&#x205f;" horiz-adv-x="374" />
<glyph unicode="&#x20ac;" d="M129 406l41 167h119q4 39 11 72t15 66h-116l41 168h127q41 94 96 171.5t131 132t175 84t230 29.5q117 0 240 -41l-90 -198q-41 16 -91 23t-91 7q-133 0 -214 -55t-137 -153h435l-68 -168h-422q-10 -29 -16 -65t-10 -73h389l-70 -167h-326q10 -127 70.5 -173.5 t155.5 -46.5q53 0 117.5 11.5t119.5 31.5l10 -200q-66 -27 -145.5 -41.5t-150.5 -14.5q-84 0 -160 23.5t-133.5 75t-91.5 134.5q-35 84 -37 200h-154z" />
<glyph unicode="&#x2122;" d="M238 1165v103h380v-103h-131v-434h-118v434h-131zM657 731q6 102 12.5 178t12.5 137.5t14.5 113.5l18.5 108h108l92 -279l97 279h110l15.5 -108.5t13.5 -115t12 -137.5t13 -176h-119q0 8 -1 53t-2 103.5t-3 120t-4 102.5l-89 -238h-90l-82 238q-2 -41 -4 -102.5t-3 -120 t-2 -103.5t-1 -53h-119z" />
<glyph unicode="&#xe000;" horiz-adv-x="965" d="M0 965h965v-965h-965v965z" />
</font>
</defs></svg>
Side by side

After

Width:  |  Height:  |  Size: 32 KiB

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-BI-webfont.ttf Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-BI-webfont.woff Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-R-webfont.eot Executable file
View file

Binary file not shown.

146
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-R-webfont.svg Executable file
View file

@ -0,0 +1,146 @@
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg">
<metadata>
This is a custom SVG webfont generated by Font Squirrel.
Copyright : Copyright 2011 Canonical Ltd Licensed under the Ubuntu Font Licence 10
Designer : Dalton Maag Ltd
Foundry : Dalton Maag Ltd
Foundry URL : httpwwwdaltonmaagcom
</metadata>
<defs>
<font id="UbuntuMonoRegular" horiz-adv-x="1024" >
<font-face units-per-em="2048" ascent="1638" descent="-410" />
<missing-glyph horiz-adv-x="500" />
<glyph unicode=" " />
<glyph unicode="!" d="M371 114.5q0 63.5 41 101.5t96 38q57 0 97 -38t40 -101.5t-40 -101.5t-97 -38q-55 0 -96 38t-41 101.5zM418 924v344h182v-344q0 -76 -2 -139.5t-7 -121t-11 -113.5l-13 -118h-116l-13 118q-6 56 -11 113.5t-7 121t-2 139.5z" />
<glyph unicode="&#x22;" d="M264 1300v91h158v-93q0 -90 -10.5 -205.5t-26.5 -211.5h-86q-14 96 -24.5 211.5t-10.5 207.5zM602 1300v91h158v-93q0 -90 -10.5 -205.5t-24.5 -211.5h-86q-16 96 -26.5 211.5t-10.5 207.5z" />
<glyph unicode="#" d="M55 334v137h158l61 326h-219v135h248l64 336h153l-63 -336h227l61 336h154l-61 -336h131v-135h-158l-63 -326h221v-137h-248l-64 -334h-153l63 334h-227l-64 -334h-153l63 334h-131zM367 471h225l63 326h-225z" />
<glyph unicode="$" d="M111 106l45 142q55 -27 130.5 -50.5t190.5 -23.5q74 0 124 11.5t79 33t41 51t12 64.5q0 51 -24.5 87t-66.5 63.5t-95 49t-111 41.5q-55 20 -109.5 45t-96.5 61t-68.5 86t-26.5 124q0 131 78 213t225 104v211h152v-205q82 -4 150.5 -19t109.5 -32l-35 -143 q-43 16 -108.5 33.5t-165.5 17.5q-111 0 -169.5 -41t-58.5 -119q0 -43 17.5 -71.5t50.5 -51t77 -41t99 -38.5q70 -27 135.5 -56.5t114.5 -70.5t78.5 -98.5t29.5 -137.5q0 -121 -79.5 -205t-245.5 -104v-236h-152v230q-129 4 -208.5 28t-118.5 47z" />
<glyph unicode="%" d="M37 977q0 156 59.5 236.5t164 80.5t163.5 -80.5t59 -236.5t-59 -238t-163.5 -82t-164 82t-59.5 238zM51 0l776 1268h144l-776 -1268h-144zM162 977q0 -92 25.5 -151.5t72.5 -59.5t71.5 59.5t24.5 151.5t-24.5 151.5t-71.5 59.5t-72.5 -59.5t-25.5 -151.5zM543 290.5 q0 155.5 58 236.5t162.5 81t164 -81t59.5 -236.5t-59.5 -236.5t-164 -81t-162.5 81t-58 236.5zM668 291q0 -92 24.5 -151.5t71.5 -59.5t72.5 59.5t25.5 151.5t-25.5 151.5t-72.5 59.5t-71.5 -59.5t-24.5 -151.5z" />
<glyph unicode="&#x26;" d="M63 309q0 96 50.5 194.5t158.5 182.5q-53 72 -85.5 145.5t-32.5 151.5q0 80 25.5 139.5t68.5 97t99 57t116 19.5q53 0 104 -16t90 -50t62.5 -83t23.5 -113q0 -94 -61 -193.5t-195 -183.5l70 -77l73 -83l77 -89q16 57 28.5 124.5t18.5 149.5l141 -18 q-12 -119 -35.5 -212.5t-58.5 -168.5q47 -66 90 -135.5t78 -147.5h-178q-35 72 -78 137q-66 -82 -147 -117.5t-169 -35.5q-78 0 -139 25.5t-104 70.5t-67 104t-24 125zM233 326q0 -80 41 -132.5t101 -65.5q18 -4 38 -4q43 0 91 20q70 30 127 112q-68 92 -141 171l-138 157 q-59 -53 -89 -122.5t-30 -135.5zM313 995q0 -59 18.5 -110t78.5 -129q98 61 139 130.5t41 129.5q0 74 -40 110.5t-91 36.5q-53 0 -99.5 -42t-46.5 -126z" />
<glyph unicode="'" d="M422 1300v91h178v-93q0 -45 -3 -103t-8 -120.5t-11.5 -123t-14.5 -107.5h-104q-8 47 -14.5 107.5t-11.5 123t-8 121.5t-3 104z" />
<glyph unicode="(" d="M231 549q0 254 117 485.5t350 401.5l90 -123h-2q-190 -147 -290.5 -340t-100.5 -420q0 -115 23.5 -217.5t72 -196.5t123 -182t177.5 -176l-93 -123q-236 174 -351.5 404.5t-115.5 486.5z" />
<glyph unicode=")" d="M231 1313l93 123q236 -174 351.5 -404.5t115.5 -486.5q0 -127 -30 -250t-88.5 -236.5t-145.5 -215t-203 -185.5l-91 123h3q190 147 291.5 339.5t101.5 420.5q0 115 -23.5 217t-73 196.5t-124.5 182.5t-177 176z" />
<glyph unicode="*" d="M117 915l55 168l14 -6q72 -29 144.5 -63.5t138.5 -71.5q-16 74 -29.5 154t-13.5 157v15h176v-15q0 -78 -13.5 -157.5t-29.5 -153.5q66 39 137.5 73t143.5 60l14 6l53 -168l-12 -4q-74 -23 -152.5 -35t-154.5 -20l114 -108q59 -56 101 -119l8 -11l-143 -104l-11 12 q-43 61 -77 134l-66 141l-68 -141q-35 -73 -81 -134l-11 -10l-141 102l10 13q45 63 103 119l112 106l-155 22q-80 11 -152 35z" />
<glyph unicode="+" d="M94 467v143h344v377h148v-377h346v-143h-346v-379h-148v379h-344z" />
<glyph unicode="," d="M305 -162l73 17q36 8 66.5 23.5t55 39t39.5 64.5q-66 6 -95.5 50t-29.5 87q0 82 46 124t105 42q76 0 115 -54.5t39 -132.5q0 -59 -23.5 -123.5t-72 -121t-120 -96.5t-169.5 -52z" />
<glyph unicode="-" d="M287 440v160h450v-160h-450z" />
<glyph unicode="." d="M362 131q0 63 41 110.5t111 47.5q68 0 109 -47t41 -111q0 -61 -41 -108.5t-109 -47.5q-70 0 -111 47.5t-41 108.5z" />
<glyph unicode="/" d="M141 -338l572 1770h170l-568 -1770h-174z" />
<glyph unicode="0" d="M94 634.5q0 319.5 109.5 490.5t308.5 171q201 0 309.5 -171t108.5 -490.5t-108.5 -490.5t-309.5 -171q-199 0 -308.5 171t-109.5 490.5zM266 634.5q0 -104.5 12.5 -197.5t41 -162.5t75.5 -110.5t117 -41t117 41t75.5 110.5t41 162.5t12.5 197.5t-12.5 198t-41 163 t-75.5 110.5t-117 41t-117 -41t-75.5 -110.5t-41 -163t-12.5 -198zM397 657.5q0 53.5 33 94.5t86 41q51 0 83 -41t32 -94.5t-32 -92.5t-83 -39q-53 0 -86 39t-33 92.5z" />
<glyph unicode="1" d="M154 1006q104 41 202.5 103t182.5 159h118v-1125h240v-143h-682v143h274v889q-23 -20 -54.5 -41.5t-69 -42t-78.5 -39t-80 -30.5z" />
<glyph unicode="2" d="M117 1145q16 18 49 45t79 50.5t103.5 39.5t122.5 16q199 0 294 -91t95 -261q0 -66 -25.5 -127t-67.5 -120.5t-95 -116.5l-109 -113l-71 -74q-41 -43 -78 -88t-61.5 -88t-24.5 -74h583v-143h-768q-2 10 -2 22v21q0 86 29 159.5t74 139.5t101 124l112 114l87 88 q42 43 73.5 86t51 89t19.5 95q0 55 -17.5 94t-47 64.5t-68.5 38t-84 12.5q-53 0 -97 -14.5t-78 -35t-58.5 -40t-36.5 -31.5z" />
<glyph unicode="3" d="M121 39l33 145q33 -16 104.5 -38.5t175.5 -22.5q162 0 230.5 64.5t68.5 172.5q0 70 -28.5 117t-75.5 76t-108.5 41t-129.5 12h-43v137h60q45 0 93 9.5t88 33t64.5 64.5t24.5 104q0 104 -64.5 148.5t-150.5 44.5q-88 0 -149.5 -25.5t-102.5 -52.5l-66 129q43 31 130 64.5 t194 33.5q100 0 172 -24.5t118 -69.5t68.5 -105.5t22.5 -131.5q0 -100 -52.5 -170t-133.5 -107q98 -29 169.5 -111.5t71.5 -220.5q0 -82 -27.5 -152.5t-84 -121.5t-145.5 -80t-212 -29q-47 0 -97 7.5t-93 18.5t-77 22.5t-48 17.5z" />
<glyph unicode="4" d="M74 324v114q35 82 95 188.5t136 220.5t162 223.5t174 197.5h164v-805h149v-139h-149v-324h-164v324h-567zM238 463h403v604q-55 -59 -111.5 -131t-109.5 -150.5t-99 -160.5t-83 -162z" />
<glyph unicode="5" d="M135 39l33 145q33 -16 101.5 -38.5t172.5 -22.5q82 0 137.5 18.5t89 50t49 72.5t15.5 86q0 70 -23.5 124t-82 91t-159.5 56.5t-255 19.5q12 90 19.5 169t12.5 153.5t8 148.5t7 156h610v-144h-462l-6 -74q-3 -46 -7 -98l-8 -98q-4 -47 -6 -76q274 -10 399 -120.5 t125 -297.5q0 -84 -26.5 -155.5t-83 -122.5t-143.5 -80t-206 -29q-49 0 -97 7.5t-91 17.5t-76 21.5t-47 19.5z" />
<glyph unicode="6" d="M111 508q0 184 50 326.5t143 238.5t226.5 147.5t300.5 53.5l15 -143q-109 -2 -198 -24t-158.5 -70t-116.5 -123.5t-72 -186.5q49 23 107.5 37t123.5 14q106 0 181 -32.5t120.5 -87t66 -126t20.5 -147.5q0 -70 -23 -142.5t-70 -133t-120.5 -98.5t-176.5 -38 q-211 0 -315 141.5t-104 393.5zM283 508q0 -80 11 -150.5t38.5 -125t75 -86t120.5 -31.5q61 0 102.5 25.5t68 64.5t38 87t11.5 91q0 125 -56.5 190.5t-177.5 65.5q-66 0 -120 -12.5t-109 -36.5q-2 -20 -2 -40v-42z" />
<glyph unicode="7" d="M129 1120v148h803v-142q-61 -72 -133 -192.5t-136.5 -271t-111.5 -321.5t-59 -341h-175q10 145 52.5 308t101.5 315.5t131 282.5t141 214h-614z" />
<glyph unicode="8" d="M104 319q0 109 59.5 193t141.5 135q-174 98 -174 301q0 70 26.5 133.5t76 110.5t120 75.5t158.5 28.5q102 0 175 -30.5t118 -78.5t65.5 -106.5t20.5 -113.5q0 -109 -55.5 -188t-126.5 -126q211 -100 211 -323q0 -160 -101.5 -258.5t-308.5 -98.5q-119 0 -196.5 32 t-124 82t-66 111.5t-19.5 120.5zM268 317q0 -33 12.5 -68.5t41 -66t75.5 -50t115 -19.5q63 0 109.5 17t76 47t44 67t14.5 73q0 117 -84 179.5t-232 95.5q-82 -45 -127 -113t-45 -162zM297 963q0 -84 60.5 -157t199.5 -106q78 45 124 106.5t46 160.5q0 27 -12.5 60.5t-38 61 t-66.5 47t-98 19.5q-59 0 -99 -18.5t-67 -46t-38 -61t-11 -66.5z" />
<glyph unicode="9" d="M104 885q0 70 23 142.5t70 132t120.5 98t176.5 38.5q209 0 315 -143t106 -393q0 -379 -184 -570.5t-555 -193.5l-6 143q229 0 369.5 91.5t185.5 314.5q-49 -23 -108.5 -36t-124.5 -13q-109 0 -182.5 31.5t-119 86t-66 124t-20.5 147.5zM276 889q0 -125 56.5 -189.5 t177.5 -64.5q66 0 122 12t109 35q2 20 2 39v39q0 80 -11 151.5t-38.5 125t-76 85t-121.5 31.5q-61 0 -102.5 -25.5t-68 -63.5t-38 -85t-11.5 -90z" />
<glyph unicode=":" d="M362 131q0 63 41 110.5t111 47.5q68 0 109 -47t41 -111q0 -61 -41 -108.5t-109 -47.5q-70 0 -111 47.5t-41 108.5zM362 793q0 63 41 110t111 47q68 0 109 -47t41 -110q0 -61 -41 -108.5t-109 -47.5q-70 0 -111 47.5t-41 108.5z" />
<glyph unicode=";" d="M256 -162l73 17q36 8 66.5 23.5t55 39t38.5 64.5q-66 6 -95 50t-29 87q0 82 46 124t105 42q76 0 115 -54.5t39 -132.5q0 -59 -23.5 -123.5t-72 -121t-120 -96.5t-169.5 -52zM362 793q0 63 41 110t111 47q68 0 109 -47t41 -110q0 -61 -41 -108.5t-109 -47.5 q-70 0 -111 47.5t-41 108.5z" />
<glyph unicode="&#x3c;" d="M100 449v145l791 336l47 -142l-649 -266l649 -268l-47 -141z" />
<glyph unicode="=" d="M94 270v146h838v-146h-838zM94 659v146h838v-146h-838z" />
<glyph unicode="&#x3e;" d="M100 254l650 268l-650 266l47 142l791 -336v-145l-791 -336z" />
<glyph unicode="?" d="M188 1223q61 35 139 54t167 19q104 0 170.5 -28.5t105.5 -72.5t54.5 -97.5t15.5 -102.5q0 -61 -23.5 -109t-58.5 -91t-76 -82t-76 -81t-58.5 -91t-23.5 -109h-145l-2 39q0 88 45 152.5t99 120t99.5 110.5t45.5 127q0 78 -49.5 125t-145.5 47q-59 0 -117.5 -14.5 t-117.5 -46.5zM330 114.5q0 63.5 40 101.5t97 38q55 0 96 -38t41 -101.5t-41 -101.5t-96 -38q-57 0 -97 38t-40 101.5z" />
<glyph unicode="@" d="M82 498q0 211 38 362.5t104.5 247.5t154.5 142t190 46q180 0 284.5 -121.5t104.5 -338.5v-707q-61 -25 -124.5 -34t-116.5 -9q-72 0 -133.5 23.5t-107.5 72.5t-71.5 126t-25.5 184q0 190 98 289.5t256 99.5q16 0 31.5 -1t32.5 -3q0 129 -53.5 204.5t-170.5 75.5 q-72 0 -131 -35t-102 -111.5t-67.5 -197.5t-24.5 -293q0 -129 24.5 -248.5t76.5 -210t133 -144.5t194 -54q82 0 170 26l16 -137q-109 -29 -200 -28q-150 0 -259.5 66.5t-180 175t-105.5 248t-35 284.5zM543 492q0 -41 5 -88.5t23.5 -87.5t52 -67.5t93.5 -27.5q16 0 36.5 2 t43.5 8v502q-18 6 -36 8t-34 2q-88 0 -136 -68t-48 -183z" />
<glyph unicode="A" d="M18 0l78 293q43 158 93 323l106 333q55 167 117 319h209q59 -152 113 -319l103 -333l91 -323l78 -293h-179l-75 332h-488l-74 -332h-172zM303 471h410q-47 184 -101.5 355t-101.5 294q-47 -129 -102.5 -299t-104.5 -350z" />
<glyph unicode="B" d="M111 20v1229q31 8 70.5 14.5t81.5 9.5t82 5t73 2q94 0 176 -16.5t142.5 -55.5t94 -102.5t33.5 -157.5q0 -45 -14 -87t-40 -79t-59.5 -64.5t-72.5 -41.5q104 -29 175 -105.5t71 -199.5q0 -188 -121 -284.5t-385 -96.5q-31 0 -72 2t-82 5t-81.5 9t-71.5 14zM279 139 q4 -2 46 -5t105.5 -3t121.5 10.5t103 38t73 72.5t28 117q0 63 -25.5 106t-67.5 68.5t-97.5 37t-114.5 11.5h-172v-453zM279 731h133q51 0 102 10.5t92 33t65.5 61t24.5 98.5q0 55 -22.5 94t-59 63.5t-85 35t-101.5 10.5t-93 -1.5t-56 -5.5v-399z" />
<glyph unicode="C" d="M94 635q0 162 42 284.5t114 206.5t168 127t205 43q76 0 154.5 -20.5t154.5 -67.5l-49 -139q-135 78 -254 78q-84 0 -150.5 -36t-114 -103.5t-73 -161.5t-25.5 -211q0 -131 28 -227.5t77 -160t117.5 -94t148.5 -30.5q59 0 124.5 15.5t135.5 54.5l45 -140 q-72 -41 -152.5 -60.5t-173.5 -19.5q-113 0 -208 40t-164.5 121t-109.5 206t-40 295z" />
<glyph unicode="D" d="M111 20v1229q129 31 256 31q123 0 228 -35t182 -112.5t121 -200.5t44 -297q0 -176 -44 -299t-121 -200t-182.5 -111.5t-227.5 -34.5q-127 -1 -256 30zM279 141q51 -6 104 -6q92 0 163.5 27.5t121 88t76 156t26.5 228.5q0 258 -99.5 379t-293.5 121q-27 0 -52.5 -1 t-45.5 -6v-987z" />
<glyph unicode="E" d="M186 0v1268h711v-144h-543v-389h475v-143h-475v-449h588v-143h-756z" />
<glyph unicode="F" d="M186 0v1268h719v-144h-551v-395h486v-141h-486v-588h-168z" />
<glyph unicode="G" d="M94 635q0 160 41 282.5t111.5 206.5t165 128t202.5 44q70 0 123.5 -10t91 -24.5t62.5 -29.5l37 -24l-56 -141q-47 37 -111.5 60.5t-135.5 23.5q-78 0 -144.5 -37t-114 -104.5t-74 -162.5t-26.5 -212q0 -115 23.5 -209t68.5 -161.5t112 -105.5t153 -38q59 0 92 8t49 16 v480h168v-594q-39 -14 -125 -36t-203 -22q-115 0 -209 44t-160.5 128t-103.5 208t-37 282z" />
<glyph unicode="H" d="M92 0v1268h168v-535h504v535h168v-1268h-168v590h-504v-590h-168z" />
<glyph unicode="I" d="M182 0v143h246v981h-246v144h660v-144h-246v-981h246v-143h-660z" />
<glyph unicode="J" d="M111 76l67 137q39 -29 103.5 -61.5t150.5 -32.5q131 0 195.5 69.5t64.5 235.5v700h-432v144h600v-860q0 -90 -19.5 -170t-67.5 -138.5t-129 -92.5t-204 -34t-206.5 35t-122.5 68z" />
<glyph unicode="K" d="M131 0v1268h168v-566q133 137 255 287t214 279h195q-100 -150 -220 -297.5t-260 -294.5q66 -55 139.5 -129t144.5 -161t133.5 -185.5t105.5 -200.5h-191q-51 94 -110.5 184t-126 168t-137 142.5t-142.5 111.5v-606h-168z" />
<glyph unicode="L" d="M186 0v1268h168v-1125h588v-143h-756z" />
<glyph unicode="M" d="M66 0q6 156 14 319.5t19.5 325.5t26.5 319.5t34 303.5h155l199 -631l197 631h157q41 -299 58.5 -612.5t31.5 -655.5h-163l-4.5 240t-5.5 266l-6 278q-3 141 -7 275l-184 -578h-148l-188 578q-2 -133 -5 -274l-6 -278l-7 -267q-3 -129 -5 -240h-163z" />
<glyph unicode="N" d="M113 0v1268h172l146 -269q62 -115 114.5 -222t101.5 -221l111 -263v975h153v-1268h-172l-131 308l-118 259l-111 229l-113 216v-1012h-153z" />
<glyph unicode="O" d="M59 635q0 170 33 295t92.5 206t142.5 120.5t185 39.5q100 0 184 -39.5t143.5 -120.5t93.5 -206t34 -295t-34 -295t-93.5 -207t-143.5 -121t-184 -39q-102 0 -185 39t-142.5 121t-92.5 207t-33 295zM231 635q0 -250 68 -383t209 -133q143 0 215 133t72 383t-72 383 t-215 133q-141 0 -209 -133t-68 -383z" />
<glyph unicode="P" d="M150 0v1249q37 8 80.5 14.5t87.5 10.5t86 5t77 1q113 0 198 -28.5t141.5 -81t84 -124t27.5 -159.5q0 -199 -117 -306.5t-350 -107.5h-148v-473h-167zM317 616h140q154 0 228.5 61.5t74.5 203.5q0 254 -266 254q-53 0 -102.5 -1t-74.5 -6v-512z" />
<glyph unicode="Q" d="M59 633q0 170 33 295t92.5 205.5t142.5 120.5t185 40q100 0 184 -40t143.5 -120.5t93.5 -205.5t34 -295q0 -152 -27 -267.5t-76 -197.5t-118.5 -129t-153.5 -62q6 -41 34.5 -70.5t72.5 -51t100.5 -36t118.5 -22.5l-39 -135q-84 14 -161 36.5t-138.5 59.5t-104.5 90.5 t-57 131.5q-166 35 -262.5 193.5t-96.5 459.5zM231 633q0 -250 68 -383t209 -133q143 0 215 133t72 383t-72 383t-215 133q-141 0 -209 -133t-68 -383z" />
<glyph unicode="R" d="M113 0v1249q31 8 70.5 14.5t81.5 9.5t83 5t74 2q229 0 345 -100.5t116 -298.5q0 -117 -61.5 -206t-166.5 -138l69 -112l77 -133l77 -146q38 -75 70 -146h-180q-61 147 -134 282.5t-140 219.5q-12 -2 -36 -2h-32h-143v-500h-170zM283 639h108q74 0 132.5 10t100.5 38 t64.5 76t22.5 126q0 74 -22.5 121t-59.5 74.5t-87 39t-106 11.5q-47 0 -91 -1t-62 -6v-489z" />
<glyph unicode="S" d="M113 61l51 140q41 -23 121 -52.5t194 -29.5q129 0 196.5 49t67.5 147q0 59 -24.5 101.5t-65.5 74t-92 55t-104 44.5q-61 25 -117.5 55.5t-100.5 71.5t-70 96t-26 131q0 166 104.5 259t291.5 93q51 0 101 -7t93 -17t77 -24.5t54 -28.5l-53 -142q-41 25 -112.5 49.5 t-159.5 24.5q-92 0 -160 -46t-68 -138q0 -53 19.5 -90t53.5 -65t79 -50.5t98 -44.5q78 -33 142.5 -66t110.5 -78t71.5 -106t25.5 -150q0 -166 -111.5 -255t-320.5 -89q-68 0 -127 9.5t-105 23.5t-81 28.5t-53 26.5z" />
<glyph unicode="T" d="M80 1124v144h864v-144h-348v-1124h-168v1124h-348z" />
<glyph unicode="U" d="M98 436v832h168v-813q0 -96 17.5 -161t49.5 -103.5t77 -55t102 -16.5t102 16.5t77 55t49.5 103t17.5 161.5v813h168v-832q0 -106 -22.5 -192t-72 -145.5t-128 -92.5t-191.5 -33t-191.5 33t-128 92.5t-72 145.5t-22.5 192z" />
<glyph unicode="V" d="M27 1268h182q25 -129 62.5 -281.5t79.5 -305.5t85 -292t80 -244l77 246q44 141 87 294t81 304.5t62 278.5h176q-16 -82 -53 -220.5t-88 -309.5l-114 -362q-62 -191 -130 -376h-208l-124 375l-112 361q-51 171 -88 310.5t-55 221.5z" />
<glyph unicode="W" d="M66 1268h163l23 -1059l184 577h148l188 -577l23 1059h163q-6 -172 -15 -344t-21.5 -335t-26.5 -312.5t-31 -276.5h-155l-199 631l-197 -631h-157q-18 125 -31.5 275.5t-25 314.5t-19.5 336t-14 342z" />
<glyph unicode="X" d="M51 0q68 152 158 329t192 341l-329 598h186l248 -486l266 486h182l-336 -592q98 -160 190.5 -332t164.5 -344h-187l-53 125l-65 143q-35 74 -75 147.5t-83 137.5q-72 -115 -143.5 -263.5l-133.5 -289.5h-182z" />
<glyph unicode="Y" d="M27 1268h188q59 -172 136 -329l165 -323q94 174 167 331t132 321h184q-78 -201 -178 -391.5t-223 -401.5v-475h-168v471q-125 205 -226 399.5t-177 397.5z" />
<glyph unicode="Z" d="M111 0v111q63 129 140 265l157 267l159 254l154 227h-580v144h774v-131q-66 -90 -146 -214l-165 -259l-163 -272q-79 -136 -138 -249h629v-143h-821z" />
<glyph unicode="[" d="M293 -338v1770h489v-134h-329v-1503h329v-133h-489z" />
<glyph unicode="\" d="M143 1432h170l568 -1770h-172z" />
<glyph unicode="]" d="M242 -205h329v1503h-329v134h489v-1770h-489v133z" />
<glyph unicode="^" d="M82 645l354 623h152l354 -623l-135 -70l-295 517l-295 -517z" />
<glyph unicode="_" d="M16 -195h992v-143h-992v143z" />
<glyph unicode="`" d="M334 1311l108 108l234 -282l-86 -76z" />
<glyph unicode="a" d="M119 283q0 82 35.5 138t92 91t129.5 50.5t146 15.5q100 0 197 -23v47q0 43 -9.5 83t-35 73t-69.5 52t-113 19q-88 0 -154 -12t-100 -24l-21 139q35 16 116 28.5t173 12.5q106 0 179 -26.5t118 -74t63.5 -115t18.5 -147.5v-594q-59 -10 -156.5 -24.5t-200.5 -14.5 q-78 0 -151.5 13.5t-131 47.5t-92 93.5t-34.5 151.5zM291 285q0 -92 62.5 -128t168.5 -36q63 0 113.5 4t83.5 10v283q-33 10 -79 16t-97 6q-47 0 -92 -7t-80 -25.5t-57.5 -48t-22.5 -74.5z" />
<glyph unicode="b" d="M145 27v1364l170 28v-504q31 18 89.5 38t130.5 20q96 0 171.5 -37t128 -102.5t80 -156.5t27.5 -202q0 -115 -32.5 -207t-92 -156.5t-143.5 -99.5t-187 -35q-113 0 -201 17t-141 33zM315 147q39 -10 78 -15t74 -5q141 0 221 87t80 261q0 74 -14.5 138.5t-45 110.5 t-78.5 72.5t-116 26.5q-59 0 -114.5 -23.5t-84.5 -49.5v-603z" />
<glyph unicode="c" d="M100 473q0 129 41 223.5t113 155.5t167 91t204 30q70 0 138 -9.5t146 -33.5l-39 -146q-68 25 -124 32t-113 7q-74 0 -139.5 -19.5t-113.5 -61.5t-77 -108.5t-29 -160.5q0 -90 27 -154.5t75 -106.5t115.5 -62.5t149.5 -20.5q66 0 126 7t132 32l25 -141 q-72 -27 -145.5 -38.5t-160.5 -11.5q-115 0 -210 32t-163.5 93.5t-106.5 154.5t-38 216z" />
<glyph unicode="d" d="M82 475q0 111 27.5 202t81 156.5t128 102.5t170.5 37q76 0 133.5 -18.5t86.5 -39.5v476l170 28v-1392q-55 -16 -141.5 -33t-200.5 -17q-102 0 -186.5 35t-144 99.5t-92 156.5t-32.5 207zM256 475q0 -166 78 -256t203 -90q63 0 107 6t65 12v603q-29 27 -84.5 50t-114.5 23 q-68 0 -116 -26.5t-78.5 -72.5t-45 -110.5t-14.5 -138.5z" />
<glyph unicode="e" d="M82 473q0 127 39 221t102.5 155.5t143 92.5t163.5 31q193 0 297.5 -120t104.5 -364v-59h-680q10 -147 97 -224t245 -77q90 0 153.5 14.5t96.5 30.5l22 -143q-31 -16 -110.5 -35t-180.5 -19q-123 0 -216 38t-154.5 103.5t-92 157t-30.5 197.5zM256 567h504 q0 121 -63.5 191.5t-168.5 70.5q-59 0 -107 -22.5t-83 -59t-55.5 -84t-26.5 -96.5z" />
<glyph unicode="f" d="M129 809v141h201v86q0 111 30.5 183.5t81 117.5t117 63.5t140 18.5t148.5 -16.5t140 -38.5l-31 -145q-45 23 -112.5 39t-136.5 16q-43 0 -81 -11.5t-67 -39t-45 -73.5t-16 -116v-84h383v-141h-383v-809h-168v809h-201z" />
<glyph unicode="g" d="M82 496q0 104 29.5 191t86 150.5t138.5 99.5t186 36q123 0 210 -17.5t147 -33.5v-848q0 -221 -112 -319.5t-337 -98.5q-92 0 -167 14.5t-132 34.5l31 150q53 -23 121.5 -37.5t150.5 -14.5q147 0 211 59.5t64 192.5v33q-29 -16 -88.5 -34.5t-137.5 -18.5 q-84 0 -156.5 27.5t-127 84t-86 143.5t-31.5 206zM256 494q0 -82 19.5 -140.5t53 -96.5t77 -55.5t92.5 -17.5q63 0 119.5 18.5t91.5 43.5v555q-25 8 -68 15t-117 7q-131 0 -199.5 -89.5t-68.5 -239.5z" />
<glyph unicode="h" d="M145 1391l170 28v-483q41 16 92.5 25.5t100.5 9.5q109 0 181.5 -32t115.5 -89t61.5 -137t18.5 -176v-537h-168v500q0 176 -49.5 248.5t-175.5 72.5q-53 0 -103.5 -11t-73.5 -22v-788h-170v1391z" />
<glyph unicode="i" d="M111 809v141h442v-583q0 -141 39 -189.5t117 -48.5q59 0 109 14.5t79 30.5l25 -143q-12 -6 -35 -15.5t-52.5 -17.5t-65.5 -14.5t-75 -6.5q-90 0 -149.5 25t-95 74t-50 121.5t-14.5 169.5v442h-274zM297 1234.5q0 63.5 39 100.5t92 37q55 0 93 -37t38 -100.5t-38 -100 t-93 -36.5q-53 0 -92 36.5t-39 100z" />
<glyph unicode="j" d="M145 -281l52 144q51 -25 113.5 -42.5t119.5 -17.5q82 0 135 42t53 163v801h-385v141h553v-940q0 -98 -27.5 -166.5t-73.5 -111.5t-106.5 -61.5t-127.5 -18.5q-78 0 -157 16t-149 51zM500 1234.5q0 63.5 39 100.5t92 37q55 0 93 -37t38 -100.5t-38 -100t-93 -36.5 q-53 0 -92 36.5t-39 100z" />
<glyph unicode="k" d="M145 0v1391l170 28v-866l226 196q113 97 202 201h199q-88 -104 -212 -215l-243 -213q55 -41 125 -103.5t138.5 -134t130 -146.5t98.5 -138h-201q-39 63 -96 130t-121.5 128t-129 112.5t-116.5 86.5v-457h-170z" />
<glyph unicode="l" d="M111 1266v143h442v-1042q0 -72 9 -117t28.5 -72.5t48.5 -38t68 -10.5q59 0 110 14.5t80 30.5l25 -143q-12 -6 -35 -15.5t-53.5 -17.5t-66.5 -14.5t-75 -6.5q-90 0 -149.5 25t-94 74t-49 121.5t-14.5 169.5v899h-274z" />
<glyph unicode="m" d="M84 0v924q123 47 231 47q59 0 111.5 -17.5t89.5 -54.5q88 72 189 72q49 0 93 -18.5t77.5 -55.5t54 -92t20.5 -129v-676h-153v680q0 74 -33 112.5t-82 38.5q-25 0 -51.5 -12t-48.5 -39q12 -47 12 -104v-309h-154v311q0 72 -22.5 112.5t-87.5 40.5q-41 0 -92 -18v-813h-154 z" />
<glyph unicode="n" d="M145 0v924q92 23 183.5 35t171.5 12q190 0 287.5 -98.5t97.5 -315.5v-557h-168v526q0 92 -16.5 149.5t-46 89.5t-71.5 44t-91 12q-41 0 -87.5 -5t-89.5 -13v-803h-170z" />
<glyph unicode="o" d="M82 475q0 113 31.5 205t89 156.5t136.5 100.5t171 36q94 0 174 -36t137.5 -100.5t89 -156.5t31.5 -205t-31.5 -204t-89 -156.5t-137.5 -101.5t-174 -36q-92 0 -171 36t-136.5 101.5t-89 156.5t-31.5 204zM256 475q0 -160 68.5 -253t185.5 -93q119 0 188.5 93t69.5 253 q0 162 -69.5 255t-188.5 93q-117 0 -185.5 -93t-68.5 -255z" />
<glyph unicode="p" d="M145 -338v1260q55 16 142.5 32.5t199.5 16.5q102 0 186.5 -35t144 -99.5t92 -156.5t32.5 -207q0 -109 -27.5 -200t-80 -156.5t-128 -102.5t-171.5 -37q-76 0 -133.5 18.5t-86.5 41.5v-375h-170zM315 201q29 -27 84.5 -49.5t114.5 -22.5q68 0 116 26.5t78.5 72.5t45 108.5 t14.5 136.5q0 166 -78 257t-203 91q-70 0 -109.5 -6t-62.5 -14v-600z" />
<glyph unicode="q" d="M82 473q0 115 32.5 207t92 156.5t144.5 99.5t188 35q111 0 195.5 -17.5t144.5 -33.5v-1258h-170v375q-31 -20 -88.5 -40t-128.5 -20q-96 0 -172 37t-128.5 102.5t-81 156.5t-28.5 200zM256 473q0 -74 15.5 -136.5t46 -108.5t78.5 -72.5t116 -26.5q59 0 114.5 22.5 t84.5 49.5v600q-23 8 -63 14t-109 6q-125 0 -204 -91t-79 -257z" />
<glyph unicode="r" d="M219 0v899q209 72 422 72q66 0 125 -5t131 -22l-31 -149q-66 18 -116 23t-109 5q-125 0 -254 -35v-788h-168z" />
<glyph unicode="s" d="M135 43l33 154q72 -33 150.5 -54.5t168.5 -21.5q231 0 232 117q0 51 -42 83.5t-104.5 57t-136.5 48.5t-136 58.5t-104 86t-42 133.5q0 115 93 191.5t292 76.5q78 0 160.5 -11.5t142.5 -29.5l-31 -152q-16 8 -45 17.5t-65.5 16.5t-78.5 11t-81 4q-221 0 -222 -120 q0 -43 42 -73t105.5 -54.5t137.5 -50t137.5 -62.5t105.5 -89t42 -132q0 -129 -100.5 -200t-317.5 -71q-98 0 -180 16.5t-156 49.5z" />
<glyph unicode="t" d="M129 809v141h201v267l168 28v-295h401v-141h-401v-442q0 -72 10 -117t33.5 -72.5t60.5 -38t90 -10.5q74 0 119 12.5t86 32.5l25 -143q-29 -12 -91.5 -33t-154.5 -21q-106 0 -174 25t-106 74t-52 121.5t-14 169.5v442h-201z" />
<glyph unicode="u" d="M139 416v534h168v-497q0 -176 52.5 -250t175.5 -74q27 0 54 2t52 5t43 6t25 5v803h170v-923q-55 -14 -146.5 -30.5t-214.5 -16.5q-109 0 -180.5 31.5t-116.5 90t-63.5 138.5t-18.5 176z" />
<glyph unicode="v" d="M61 950h185q25 -90 56 -190l67 -201l70.5 -193.5t70.5 -166.5q35 74 73 167t74 193l71 201q34 100 58 190h177q-37 -133 -84 -261l-97 -250q-49 -122 -100 -232l-98 -207h-154q-96 193 -194.5 438.5t-174.5 511.5z" />
<glyph unicode="w" d="M39 950h160q6 -80 13 -156.5t17.5 -160.5l23.5 -182l30 -222q33 82 55 143.5l41 116.5l36 113l38 129h127l36 -129q16 -57 35 -113l39 -116q20 -61 51 -142l32.5 209.5t25 181.5t18.5 164.5t14 163.5h154q-10 -102 -24.5 -219t-35 -239.5t-45 -248.5t-51.5 -243h-127 q-31 70 -53 127l-44 115l-43 119l-50 143l-51 -143l-44 -119l-45 -115l-55 -127h-127q-57 252 -95 498.5t-56 451.5z" />
<glyph unicode="x" d="M59 0q68 123 165 253l192 247l-342 450h190l256 -332l236 332h180l-313 -440l185 -252q93 -131 159 -258h-189q-20 41 -50 90l-64.5 101.5t-72.5 103.5l-75 96l-78 -98q-41 -51 -79 -104l-70 -101q-33 -49 -56 -88h-174z" />
<glyph unicode="y" d="M74 -315l30 137q18 -10 52 -16.5t63 -6.5q100 0 156.5 44t103.5 145q-115 217 -215 465.5t-166 496.5h185q20 -82 47.5 -177t62.5 -195.5t75 -202t85 -193.5q33 94 61.5 186.5t53.5 185.5l49 190l51 206h176q-66 -266 -146.5 -516t-172.5 -463q-35 -82 -75 -141t-87 -98 t-106.5 -57.5t-135.5 -18.5q-39 0 -85 10.5t-62 18.5z" />
<glyph unicode="z" d="M150 0v113q43 82 107.5 179l133.5 192l136 182q67 86 116 143h-467v141h684v-127l-100 -120l-136 -169q-73 -93 -144.5 -195.5t-127.5 -195.5h522v-143h-724z" />
<glyph unicode="{" d="M162 481v131h82q35 0 61.5 15.5t44 41t26.5 57.5t9 65v329q0 76 15.5 133.5t52 97.5t99 60.5t157.5 20.5h165v-134h-174q-86 0 -121.5 -38.5t-35.5 -141.5v-282q0 -137 -41 -202t-94 -87q53 -25 94 -92.5t41 -196.5v-283q0 -102 36.5 -141t122.5 -39h172v-133h-165 q-94 0 -157 20.5t-99.5 60.5t-52 97.5t-15.5 132.5v330q0 31 -9 62.5t-26.5 57.5t-43 42t-60.5 16h-84z" />
<glyph unicode="|" d="M434 -338v1770h158v-1770h-158z" />
<glyph unicode="}" d="M150 -205h174q86 0 121.5 39t35.5 141v283q0 137 41 201.5t94 87.5q-53 25 -94 92.5t-41 196.5v282q0 102 -36.5 141t-122.5 39h-172v134h165q94 0 157 -20.5t100.5 -60.5t53 -97.5t15.5 -133.5v-329q0 -31 8 -63t25.5 -57.5t43 -42t60.5 -16.5h84v-131h-82 q-35 0 -60.5 -15t-43 -41t-26.5 -57.5t-9 -64.5v-330q0 -76 -15.5 -133t-53 -97t-100 -60.5t-157.5 -20.5h-165v133z" />
<glyph unicode="~" d="M76 434q6 35 22.5 80t45 84t72.5 65.5t110 26.5q55 0 101 -21.5t89 -47.5l95 -58q46 -29 98 -28q29 0 49 13t33.5 33.5t23.5 46t16 48.5l117 -33q-6 -35 -21.5 -80t-45 -84t-74.5 -65.5t-109 -26.5q-55 0 -101 21.5t-89 48.5l-94 57q-45 29 -99 29q-29 0 -49 -13.5 t-33.5 -34t-23.5 -46t-16 -48.5z" />
<glyph unicode="&#xa0;" />
<glyph unicode="&#xa2;" d="M100 532q0 109 31 192t86 142.5t132 94t167 47.5v260h152v-254q55 -4 110.5 -13.5t118.5 -29.5l-37 -142q-68 25 -123 32t-112 7q-74 0 -138.5 -19.5t-111.5 -59t-74 -104t-27 -153.5q0 -170 101.5 -250.5t265.5 -80.5q66 0 125 8t131 33l25 -140q-61 -23 -123 -33 t-131 -14v-254h-152v258q-188 27 -302 145.5t-114 327.5z" />
<glyph unicode="&#xa3;" d="M92 545v137h170v152q0 135 28.5 224t80 140t124 71.5t162.5 20.5q80 0 134.5 -13t105.5 -36l-41 -145q-92 45 -207 45q-49 0 -89 -14.5t-69.5 -49.5t-45 -93t-15.5 -146v-156h348v-137h-348v-15q0 -92 -7 -192t-22 -193h531v-145h-721q20 131 35.5 259t15.5 259v27h-170z " />
<glyph unicode="&#xa5;" d="M27 1268h186q66 -143 143.5 -285.5t161.5 -273.5q80 131 155 273t140 286h186l-170 -311q-88 -157 -188 -316h252v-131h-295v-186h295v-129h-295v-195h-168v195h-297v129h297v186h-297v131h250q-100 160 -189 318z" />
<glyph unicode="&#xa9;" d="M70 473q0 125 38.5 219t101 156.5t142.5 93.5t162 31t162 -31t141.5 -93.5t99 -155.5t37.5 -216q0 -125 -38.5 -218t-101 -155.5t-142.5 -94.5t-162 -32q-84 0 -163 32t-140.5 93.5t-99 154.5t-37.5 216zM188 477q0 -98 28 -171t74 -121t103.5 -72.5t118.5 -24.5 t119.5 24.5t103.5 72.5t73 120t28 168q0 98 -28 171t-74 121t-103.5 72.5t-118.5 24.5t-118.5 -24.5t-103.5 -72.5t-74 -121t-28 -167zM291 469q0 49 14 96t43 84t73 59.5t105 22.5q33 0 69 -5t71 -21l-41 -111q-23 10 -45.5 13t-40.5 3q-66 0 -93.5 -41t-27.5 -92 q0 -66 33.5 -103.5t95.5 -37.5q18 0 41.5 4t46.5 14l35 -108q-35 -16 -73 -24.5t-73 -8.5q-59 0 -103 21.5t-73 57.5t-43 82t-14 95z" />
<glyph unicode="&#xad;" d="M287 440v160h450v-160h-450z" />
<glyph unicode="&#xae;" d="M70 473q0 125 38.5 219t101 156.5t142.5 93.5t162 31t162 -31t141.5 -93.5t99 -155.5t37.5 -216q0 -125 -38.5 -218t-101 -155.5t-142.5 -94.5t-162 -32q-84 0 -163 32t-140.5 93.5t-99 154.5t-37.5 216zM188 477q0 -98 28 -171t74 -121t103.5 -72.5t118.5 -24.5 t119.5 24.5t103.5 72.5t73 120t28 168q0 98 -28 171t-74 121t-103.5 72.5t-118.5 24.5t-118.5 -24.5t-103.5 -72.5t-74 -121t-28 -167zM340 225v488q29 8 63.5 13t73.5 5q117 0 173.5 -45t56.5 -131q0 -98 -82 -145q25 -35 51 -83l53 -102h-117l-47 87q-20 38 -41 71h-73 v-158h-111zM451 485h36q55 0 82 14.5t27 61.5q0 41 -33 54.5t-67 13.5q-12 0 -23.5 -1t-21.5 -3v-140z" />
<glyph unicode="&#xb4;" d="M348 1137l234 282l110 -108l-258 -250z" />
<glyph unicode="&#x2000;" horiz-adv-x="727" />
<glyph unicode="&#x2001;" horiz-adv-x="1454" />
<glyph unicode="&#x2002;" horiz-adv-x="727" />
<glyph unicode="&#x2003;" horiz-adv-x="1454" />
<glyph unicode="&#x2004;" horiz-adv-x="483" />
<glyph unicode="&#x2005;" horiz-adv-x="362" />
<glyph unicode="&#x2006;" horiz-adv-x="241" />
<glyph unicode="&#x2007;" horiz-adv-x="241" />
<glyph unicode="&#x2008;" horiz-adv-x="180" />
<glyph unicode="&#x2009;" horiz-adv-x="290" />
<glyph unicode="&#x200a;" horiz-adv-x="79" />
<glyph unicode="&#x2010;" d="M287 440v160h450v-160h-450z" />
<glyph unicode="&#x2011;" d="M287 440v160h450v-160h-450z" />
<glyph unicode="&#x2012;" d="M287 440v160h450v-160h-450z" />
<glyph unicode="&#x2013;" d="M141 483v144h742v-144h-742z" />
<glyph unicode="&#x2014;" d="M0 483v144h1024v-144h-1024z" />
<glyph unicode="&#x2018;" d="M305 1061q0 59 23.5 123.5t70.5 121t120 96.5t169 52l31 -133l-73 -16q-36 -8 -66.5 -23.5t-55 -40t-39.5 -63.5q66 -6 95.5 -50.5t29.5 -87.5q0 -82 -47 -124t-104 -42q-76 0 -115 54.5t-39 132.5z" />
<glyph unicode="&#x2019;" d="M303 1001l73 17q36 8 66.5 23.5t55 39t39.5 64.5q-66 6 -95.5 50t-29.5 87q0 82 47 124t104 42q76 0 115 -54.5t39 -131.5q0 -59 -23.5 -124t-72 -121t-120 -96t-167.5 -53z" />
<glyph unicode="&#x201c;" d="M88 1071q0 57 17.5 114.5t57.5 104.5t106.5 82t166.5 47l29 -119l-68 -15q-33 -7 -61.5 -21.5t-51 -36t-34.5 -58.5q59 -6 89 -46t30 -89q0 -51 -33 -93t-103 -42q-59 0 -102 41t-43 131zM561 1071q0 57 17.5 114.5t57.5 104.5t106.5 82t166.5 47l29 -119l-68 -15 q-33 -7 -60.5 -21.5t-50 -36t-34.5 -58.5q59 -6 89 -46t30 -89q0 -51 -34 -93t-101 -42q-59 0 -103.5 41t-44.5 131z" />
<glyph unicode="&#x201d;" d="M86 1018l68 15q33 7 60.5 21.5t50 37t34.5 59.5q-59 4 -89 45t-30 88q0 51 34 93t101 42q59 0 103.5 -41t44.5 -131q0 -59 -17.5 -115.5t-57.5 -103.5t-106.5 -82t-166.5 -47zM559 1018l68 15q33 7 61.5 21.5t51 37t34.5 59.5q-59 4 -89 45t-30 88q0 51 33 93t103 42 q59 0 102 -41t43 -131q0 -59 -17.5 -115.5t-57.5 -103.5t-106.5 -82t-164.5 -47z" />
<glyph unicode="&#x2022;" d="M233 647q0 57 19.5 110.5t55.5 94.5t87 64.5t117 23.5q63 0 115.5 -23.5t88.5 -64.5t55.5 -94t19.5 -111q0 -59 -19.5 -112.5t-55.5 -93.5t-88.5 -63.5t-115.5 -23.5q-66 0 -117 23.5t-87 63.5t-55.5 93.5t-19.5 112.5z" />
<glyph unicode="&#x2026;" d="M63 86q0 45 30 78t79 33t79 -33t30 -78t-30 -78t-79 -33t-79 33t-30 78zM408 86q0 45 28.5 78t77.5 33t78 -33t29 -78t-29 -78t-78 -33t-77.5 33t-28.5 78zM748 86q0 45 28.5 78t77.5 33t78 -33t29 -78t-29 -78t-78 -33t-77.5 33t-28.5 78z" />
<glyph unicode="&#x202f;" horiz-adv-x="290" />
<glyph unicode="&#x205f;" horiz-adv-x="362" />
<glyph unicode="&#x20ac;" d="M74 416v131h125q-2 20 -2 43v45v50q0 24 2 46h-125v131h143q37 217 154.5 322.5t312.5 105.5q82 0 134 -10t102 -29l-33 -143q-43 16 -95.5 26.5t-107.5 10.5q-139 0 -204.5 -77t-86.5 -206h408l-25 -131h-401q-2 -23 -2 -46v-50v-45q0 -23 2 -43h366l-24 -131h-328 q27 -164 101.5 -227.5t197.5 -63.5q78 0 133.5 13.5t98.5 35.5l36 -145q-31 -16 -107.5 -35t-170.5 -19q-213 0 -324.5 117t-140.5 324h-139z" />
<glyph unicode="&#x2122;" d="M37 1165v103h381v-103h-131v-434h-119v434h-131zM457 731q6 102 12 178t13 137.5t14.5 113.5t17.5 108h111l90 -279l96 279h111q10 -55 17 -108.5t13 -115t11.5 -137.5t11.5 -176h-119q0 8 -1 53t-2 103.5t-3 120t-4 102.5l-86 -238h-92l-80 238q-4 -41 -6 -102.5 t-3 -120t-2.5 -103.5t-1.5 -53h-118z" />
<glyph unicode="&#xe000;" horiz-adv-x="950" d="M0 950h950v-950h-950v950z" />
</font>
</defs></svg>
Side by side

After

Width:  |  Height:  |  Size: 30 KiB

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-R-webfont.ttf Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-R-webfont.woff Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-RI-webfont.eot Executable file
View file

Binary file not shown.

146
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-RI-webfont.svg Executable file
View file

@ -0,0 +1,146 @@
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<svg xmlns="http://www.w3.org/2000/svg">
<metadata>
This is a custom SVG webfont generated by Font Squirrel.
Copyright : Copyright 2011 Canonical Ltd Licensed under the Ubuntu Font Licence 10
Designer : Dalton Maag Ltd
Foundry : Dalton Maag Ltd
Foundry URL : httpwwwdaltonmaagcom
</metadata>
<defs>
<font id="UbuntuMonoItalic" horiz-adv-x="1024" >
<font-face units-per-em="2048" ascent="1638" descent="-410" />
<missing-glyph horiz-adv-x="500" />
<glyph unicode=" " />
<glyph unicode="!" d="M354 98q0 74 42 115t102 41q53 0 89 -32t36 -93q0 -72 -46.5 -113t-101.5 -41q-53 0 -87 31t-34 92zM500 432l15 118q7 56 16.5 113.5t21.5 121t31 139.5l82 344h182l-82 -344q-18 -76 -35.5 -139.5t-36.5 -120.5l-38 -114l-40 -118h-116z" />
<glyph unicode="&#x22;" d="M453 881q10 96 27.5 211.5t39.5 207.5l21 91h157l-22 -93q-23 -90 -59.5 -205.5t-77.5 -211.5h-86zM793 881q8 96 24.5 211.5t38.5 207.5l23 91h155l-20 -93q-23 -90 -59.5 -205.5t-75.5 -211.5h-86z" />
<glyph unicode="#" d="M82 0l143 334h-131l33 137h156l141 326h-219l33 135h249l142 336h153l-141 -336h225l144 336h153l-143 -336h133l-33 -135h-159l-142 -326h221l-32 -137h-248l-146 -334h-153l145 334h-227l-146 -334h-151zM438 471h226l141 326h-225z" />
<glyph unicode="$" d="M143 123l82 135q33 -20 100.5 -49t174.5 -29q53 0 105 9.5t93 33t67 61.5t26 97q0 41 -16.5 69.5t-44.5 52t-67 43.5l-85 42q-41 18 -80 41.5t-70 57.5t-50.5 81t-19.5 113q0 131 89.5 219t263.5 110l49 209h149l-49 -205q78 -8 140.5 -31.5t97.5 -45.5l-78 -127 q-31 23 -90.5 42t-147.5 19q-53 0 -100 -10t-82 -31.5t-55.5 -55.5t-20.5 -79q0 -76 46 -116t139 -85q51 -23 96 -47t79 -59t54 -82t20 -111q0 -80 -27.5 -142.5t-78.5 -107.5t-120.5 -72.5t-156.5 -35.5l-53 -236h-149l57 238q-94 4 -174 32.5t-113 51.5z" />
<glyph unicode="%" d="M10 0l1080 1268h147l-1079 -1268h-148zM203 874q0 61 15 135t50 136.5t89.5 105.5t134.5 43q176 0 176 -211q0 -102 -23.5 -181t-63.5 -133t-91.5 -83t-108.5 -29q-86 0 -132 55.5t-46 161.5zM330 891q0 -57 16 -91t53 -34q39 0 66 36t44 84t24.5 99t7.5 82 q0 53 -16.5 87t-51.5 34q-27 0 -52.5 -23.5t-46 -64.5t-32.5 -95.5t-12 -113.5zM580 188q0 61 15 135t50 136.5t89 105.5t134 43q176 0 176 -211q0 -102 -23.5 -181t-63 -133t-91 -82t-108.5 -28q-86 0 -132 54.5t-46 160.5zM707 205q0 -57 16 -91t53 -34q39 0 65.5 36 t44 84t24.5 99q8 51 8 82q0 53 -16.5 87t-51.5 34q-27 0 -52.5 -23.5t-46 -64.5t-32.5 -95.5t-12 -113.5z" />
<glyph unicode="&#x26;" d="M117 252q0 49 13 103.5t43 107.5t80 104t124 99l41 26q-31 57 -49.5 112.5t-18.5 110.5q0 90 31 161t83 120t120.5 74.5t142.5 25.5q45 0 86 -13t71.5 -38.5t48 -65.5t17.5 -94q0 -49 -16 -103t-53 -108.5t-98.5 -107.5t-149.5 -98l-23 -11l49 -79l51 -81l52 -85 q57 113 100 270l144 -18q-35 -121 -78 -217.5t-90 -172.5q29 -59 53 -124.5t47 -149.5h-176q-16 70 -37 135q-82 -80 -169 -115.5t-175 -35.5q-59 0 -107.5 20.5t-83 57t-54 86t-19.5 104.5zM291 276q0 -66 34.5 -108.5t108.5 -42.5q57 0 116.5 34t119.5 105q-45 92 -96 171 l-95 153l-18 -13q-53 -33 -86 -67.5t-51.5 -71.5t-25.5 -77t-7 -83zM510 918q0 -41 9 -77t32 -81l33 16q51 27 91 62.5t66.5 75.5t40 80t13.5 75q0 47 -32 70.5t-73 23.5q-33 0 -65.5 -14t-58 -45t-41 -77t-15.5 -109z" />
<glyph unicode="'" d="M614 844q4 47 11.5 107.5t17.5 123t21.5 121.5t23.5 104l21 91h176l-23 -93q-10 -45 -26.5 -103t-36.5 -121l-41 -123q-20 -60 -39 -107h-105z" />
<glyph unicode="(" d="M299 322q0 162 51 320.5t144.5 304t223.5 271t288 218.5l65 -131q-133 -84 -244.5 -195t-193.5 -236.5t-127 -263t-45 -278.5q0 -147 53 -290.5t176 -272.5l-110 -111q-147 147 -214 317.5t-67 346.5z" />
<glyph unicode=")" d="M115 -211q133 84 245.5 194.5t193.5 236.5t127 263.5t46 278.5q0 147 -54.5 290.5t-174.5 272.5l108 111q147 -147 215 -317.5t68 -346.5q0 -162 -51.5 -320.5t-144.5 -304t-223 -271.5t-290 -218z" />
<glyph unicode="*" d="M283 915l53 168l14 -6q72 -29 144.5 -63.5t138.5 -71.5q-16 74 -29.5 154t-13.5 157v15h176v-15q0 -78 -13.5 -157.5t-27.5 -153.5q66 39 137.5 73t141.5 60l14 6l53 -168l-12 -4q-72 -23 -152 -35t-155 -20l115 -108q58 -56 100 -119l8 -11l-144 -104l-8 12 q-45 61 -80 134l-65 141l-67 -141q-36 -73 -83 -134l-8 -10l-141 102l8 13q47 63 103 119l114 106l-155 22q-80 11 -152 35z" />
<glyph unicode="+" d="M176 467l35 143h336l92 377h156l-93 -377h330l-35 -143h-329l-93 -379h-153l90 379h-336z" />
<glyph unicode="," d="M215 -162q35 2 75 12.5t75.5 28t64.5 43t41 62.5q-57 8 -86 48t-29 89q0 70 44 117t122 47q68 0 104 -48.5t36 -119.5q0 -59 -25 -125t-77 -125.5t-134 -103.5t-195 -58z" />
<glyph unicode="-" d="M360 440l39 160h449l-37 -160h-451z" />
<glyph unicode="." d="M356 113q0 86 48.5 131t113.5 45q57 0 98 -36t41 -108q0 -39 -14 -69.5t-37.5 -53t-53.5 -35t-60 -12.5q-57 0 -96.5 35t-39.5 103z" />
<glyph unicode="/" d="M-35 -338l998 1770h170l-996 -1770h-172z" />
<glyph unicode="0" d="M172 352q0 90 16.5 195.5t49 210t82 202t116 172t149.5 119.5t185 45q156 0 229.5 -95t73.5 -286q0 -90 -16.5 -194.5t-49 -209.5t-81.5 -201.5t-116 -171.5t-151 -120t-184 -45q-156 0 -229.5 95.5t-73.5 283.5zM344 375q0 -137 34 -194.5t118 -57.5q86 0 160.5 74.5 t129 188.5t85 250t30.5 259q0 137 -32.5 194.5t-118.5 57.5t-160 -75t-129 -189.5t-86 -249.5t-31 -258zM504 641q0 72 40 112t93 40q47 0 81 -32t34 -91q0 -66 -42 -106t-96 -40q-47 0 -78.5 29t-31.5 88z" />
<glyph unicode="1" d="M188 0l35 143h275l209 873q-25 -18 -61 -40t-77 -42.5t-85 -38.5t-85 -31l-28 142q115 41 227.5 103t216.5 159h121l-270 -1125h237l-35 -143h-680z" />
<glyph unicode="2" d="M141 0q14 98 51 176t89.5 143.5t116 121t130.5 106.5l139 103q67 50 118 102.5t81.5 109t30.5 123.5q0 76 -41 120t-133 44q-51 0 -97 -13.5t-83 -32t-64.5 -39t-44.5 -36.5l-59 131q25 25 63.5 48.5t86.5 44t103.5 32.5t114.5 12q88 0 151.5 -24.5t102.5 -64.5t57.5 -92 t18.5 -105q0 -96 -30.5 -170t-83 -135.5t-122.5 -115.5l-149 -112l-97 -75q-50 -40 -96 -83t-81 -88t-49 -88h550l-34 -143h-740z" />
<glyph unicode="3" d="M123 47l63 146q27 -16 92.5 -43t174.5 -27q74 0 136 17.5t108 52t72 87t26 121.5q0 109 -79 157t-212 48h-37l33 137h55q59 0 117.5 16.5t104.5 48.5t75 79t29 108q0 78 -47.5 117t-133.5 39q-78 0 -141 -25.5t-108 -54.5l-41 133q25 16 59.5 32.5t76.5 30t88 21.5t93 8 q86 0 147.5 -21.5t101.5 -60t58.5 -90t18.5 -110.5q0 -123 -70 -207t-190 -131q31 -12 62.5 -36t56 -57.5t40 -78.5t15.5 -101q0 -96 -34 -176t-99.5 -136t-163 -87t-224.5 -31q-63 0 -117.5 8.5t-96.5 20.5t-70.5 24.5t-38.5 20.5z" />
<glyph unicode="4" d="M98 324l29 114q51 86 134 196.5t184.5 224.5t214 220.5t221.5 188.5h166l-195 -805h147l-32 -139h-148l-76 -324h-165l77 324h-557zM305 463h385l141 592q-66 -55 -136 -124t-140 -145.5t-134.5 -158.5t-115.5 -164z" />
<glyph unicode="5" d="M115 43l65 143q27 -16 89.5 -39.5t164.5 -23.5q74 0 139.5 19.5t112.5 55t74.5 88t27.5 117.5q0 86 -46 134.5t-113.5 73t-146.5 31.5t-144 11l57 161l51 151q25 74 47.5 148.5t43.5 154.5h591l-32 -144h-441l-27 -84l-32 -95l-32 -92q-15 -44 -23 -75 q209 -27 314.5 -112.5t105.5 -245.5q0 -94 -32 -175t-97.5 -141.5t-167 -95.5t-240.5 -35q-59 0 -110.5 9.5t-93.5 20.5t-69.5 22.5t-35.5 17.5z" />
<glyph unicode="6" d="M197 338q0 193 64.5 362.5t183 296.5t285.5 202t372 75h24l-20 -146h-8q-129 0 -234.5 -33.5t-187.5 -90t-140.5 -131t-91.5 -156.5q59 29 127 45t129 16q82 0 141.5 -24.5t98.5 -66.5t56.5 -96t17.5 -116q0 -92 -28 -181t-87 -161t-151.5 -116t-221.5 -44 q-160 0 -244.5 97.5t-84.5 267.5zM365 352q0 -115 40.5 -178t145.5 -63q72 0 127 30.5t92 79.5t56.5 110.5t19.5 125.5q0 88 -43 134t-144 46q-66 0 -129 -11.5t-129 -43.5q-18 -59 -27 -120t-9 -110z" />
<glyph unicode="7" d="M285 0q41 145 119.5 307t176 315.5t203 285.5t199.5 216h-602l33 144h794l-34 -148q-78 -68 -180.5 -187.5t-204 -270t-188.5 -321.5t-136 -341h-180z" />
<glyph unicode="8" d="M162 258q0 133 76.5 235.5t214.5 168.5q-111 88 -111 227q0 82 29.5 155.5t87 130t138.5 89t183 32.5q86 0 146.5 -24.5t99.5 -63.5t57.5 -90t18.5 -102q0 -127 -72 -221.5t-196 -155.5q61 -43 105 -103.5t44 -158.5q0 -80 -30.5 -153.5t-91 -129t-152 -88.5t-211.5 -33 q-92 0 -155.5 26t-103.5 65.5t-58.5 91t-18.5 102.5zM330 287q0 -35 9 -67t30.5 -56.5t58.5 -38.5t92 -14q61 0 114.5 18t93.5 51t62.5 79t22.5 101q0 90 -61.5 144.5t-171.5 93.5q-49 -23 -95.5 -55.5t-80 -72.5t-54 -87t-20.5 -96zM508 905q0 -76 46 -125t146 -84 q45 23 87 52.5t75 66.5t51.5 82t18.5 100q0 27 -7 55.5t-26.5 52t-53.5 38t-85 14.5q-53 0 -99.5 -18.5t-80 -52t-53 -80t-19.5 -101.5z" />
<glyph unicode="9" d="M152 -2l30 145q6 -2 18 -2h15q129 0 230.5 32t178 88t132 132t92.5 162q-59 -29 -126 -43t-130 -14q-82 0 -141.5 23.5t-97.5 64.5t-56 95t-18 116q0 92 28.5 181t87 159.5t148.5 113.5t211 43q170 0 256 -98t86 -266q0 -197 -61.5 -367t-177.5 -296t-281.5 -198.5 t-376.5 -72.5h-20q-9 0 -27 2zM446 815q0 -88 44.5 -132t142.5 -44q66 0 130 11.5t130 41.5q35 115 35 240q0 100 -44 161.5t-143 61.5q-72 0 -127 -29.5t-92 -78t-56.5 -109t-19.5 -123.5z" />
<glyph unicode=":" d="M356 113q0 86 48.5 131t113.5 45q57 0 98 -36t41 -108q0 -39 -14 -69.5t-37.5 -53t-53.5 -35t-60 -12.5q-57 0 -96.5 35t-39.5 103zM514 772q0 86 48 131t114 45q57 0 98 -35.5t41 -107.5q0 -39 -14.5 -69.5t-38 -53.5t-53 -35t-60.5 -12q-57 0 -96 34.5t-39 102.5z" />
<glyph unicode=";" d="M215 -162q35 2 75 12.5t75.5 28t64.5 43t41 62.5q-57 8 -86 48t-29 89q0 70 44 117t122 47q68 0 104 -48.5t36 -119.5q0 -59 -25 -125t-77 -125.5t-134 -103.5t-195 -58zM514 772q0 86 48 131t114 45q57 0 98 -35.5t41 -107.5q0 -39 -14.5 -69.5t-38 -53.5t-53 -35 t-60.5 -12q-57 0 -96 34.5t-39 102.5z" />
<glyph unicode="&#x3c;" d="M160 449l35 145l856 336l10 -152l-699 -266l570 -264l-78 -135z" />
<glyph unicode="=" d="M129 270l35 146h821l-35 -146h-821zM223 659l35 146h821l-35 -146h-821z" />
<glyph unicode="&#x3e;" d="M123 264l698 266l-569 265l78 135l694 -336l-35 -145l-856 -336z" />
<glyph unicode="?" d="M334 98q0 74 43 115t100 41q53 0 89 -32t36 -93q0 -72 -46 -113t-101 -41q-53 0 -87 31t-34 92zM463 432l6 39q10 59 46 108.5t83 93.5t99.5 84t95.5 82t71.5 87t28.5 100q0 57 -38 94t-124 37q-59 0 -115.5 -12t-121.5 -43l-19 131q49 27 125 45t156 18q57 0 112.5 -12 t98.5 -41t68.5 -77t25.5 -117q0 -76 -30 -134.5t-76 -106.5t-101 -89t-105.5 -84t-88 -92t-48.5 -111h-149z" />
<glyph unicode="@" d="M141 315q0 111 21.5 227.5t62.5 225.5t100.5 206t135.5 168.5t167 113.5t195 42q164 0 243 -88t79 -227q0 -72 -19 -147l-170 -707q-49 -20 -102 -30.5t-102 -10.5q-61 0 -115.5 17.5t-96.5 54.5t-66.5 95t-24.5 142q0 94 27.5 181.5t83.5 155t144.5 107.5t210.5 40 q14 0 30 -1t32 -3q12 51 12 100q0 78 -40 128t-138 50q-111 0 -205 -79t-162.5 -201.5t-106.5 -271t-38 -288.5q0 -92 18.5 -174t56.5 -142t97 -96t143 -36q35 0 73 5t81 17l-14 -137q-92 -25 -170 -24q-115 0 -199 45t-138 124.5t-80 187t-26 230.5zM606 399q0 -86 38 -132 t110 -46q16 0 31.5 2t35.5 8l121 502q-37 12 -70 12q-66 0 -115.5 -28.5t-83.5 -75.5t-50.5 -109.5t-16.5 -132.5z" />
<glyph unicode="A" d="M-27 0l150 293l171 323l184 333q95 167 192 319h200q23 -152 38.5 -319t25.5 -332.5t16 -323.5l11 -293h-177l2 332h-487l-156 -332h-170zM371 471h409q-4 184 -18 355t-31 294l-172 -299z" />
<glyph unicode="B" d="M92 20l293 1229q33 8 74 14.5t84 9.5t83 5t72 2q166 0 269.5 -60.5t103.5 -197.5q0 -121 -58.5 -211t-193.5 -143q72 -20 125 -84t53 -150q0 -213 -156.5 -328.5t-449.5 -115.5q-33 0 -72.5 2t-80.5 5t-79 9t-67 14zM285 139q4 -2 45 -5t106 -3q68 0 137.5 12.5t126 46 t92 90t35.5 146.5q0 94 -73.5 130t-186.5 36h-172zM428 731h133q61 0 122.5 11.5t111 41t79 78.5t29.5 123q0 41 -18.5 69.5t-49 47t-72.5 27t-87 8.5q-53 0 -93 -1t-59 -6z" />
<glyph unicode="C" d="M182 414q0 162 47 320.5t136.5 283.5t216.5 201.5t286 76.5q123 0 198 -32.5t110 -61.5l-80 -135q-35 31 -101.5 55.5t-138.5 24.5q-119 0 -212 -61.5t-157.5 -162t-99.5 -226.5t-35 -257q0 -147 65.5 -232t190.5 -85q98 0 174 25.5t113 48.5l18 -144 q-12 -10 -43.5 -23.5t-75.5 -25.5t-101.5 -21.5t-121.5 -9.5q-180 0 -284.5 119t-104.5 322z" />
<glyph unicode="D" d="M74 18l293 1231q135 31 260 31q209 0 326.5 -118t117.5 -333q0 -162 -43 -313t-133 -268t-229.5 -187.5t-331.5 -70.5q-66 0 -133.5 6t-126.5 22zM270 145q16 -4 45 -7t54 -3q115 0 212 49t168.5 138.5t111.5 214.5t40 274q0 156 -71.5 240t-225.5 84q-55 0 -100 -7z" />
<glyph unicode="E" d="M145 0l308 1268h708l-35 -144h-540l-94 -389h475l-35 -143h-475l-107 -449h586l-35 -143h-756z" />
<glyph unicode="F" d="M145 0l308 1268h718l-34 -144h-551l-97 -395h486l-35 -141h-485l-140 -588h-170z" />
<glyph unicode="G" d="M164 414q0 162 47 320.5t136 283.5t216 201.5t287 76.5q63 0 110.5 -9t82 -23.5t59 -30.5t41.5 -31l-80 -135q-35 31 -92.5 56.5t-132.5 25.5q-119 0 -212.5 -61.5t-158 -162t-99 -227.5t-34.5 -258q0 -147 65.5 -233t190.5 -86q51 0 89 7t60 15l115 480h168l-141 -594 q-16 -6 -50 -15.5t-79 -18.5t-99.5 -15.5t-109.5 -6.5q-86 0 -157 31t-120 88t-75.5 139.5t-26.5 182.5z" />
<glyph unicode="H" d="M74 0l303 1268h168l-127 -535h467l129 535h168l-305 -1268h-168l141 590h-467l-143 -590h-166z" />
<glyph unicode="I" d="M145 0l35 143h244l235 981h-243l35 144h657l-35 -144h-244l-237 -981h246l-35 -143h-658z" />
<glyph unicode="J" d="M137 90l88 133q14 -14 37 -32.5t53.5 -34t67.5 -26.5t82 -11q123 0 191.5 72.5t107.5 232.5l168 700h-430l33 144h600l-205 -860q-23 -88 -51.5 -167t-81 -138.5t-133 -94.5t-203.5 -35q-63 0 -115.5 12.5t-94.5 30t-71 38t-43 36.5z" />
<glyph unicode="K" d="M92 0l303 1268h168l-133 -555q172 154 310.5 290t254.5 265h209l-146 -152l-149 -147l-155 -151l-172 -159q43 -49 93 -117.5t99 -153.5t96.5 -183.5t85.5 -204.5h-182q-78 217 -170 365.5t-198 244.5l-146 -610h-168z" />
<glyph unicode="L" d="M111 0l305 1268h168l-271 -1125h549l-33 -143h-718z" />
<glyph unicode="M" d="M37 0q88 328 184 638t213 630h156q14 -166 24.5 -317.5l22.5 -313.5l348 631h158q-12 -129 -35 -278.5t-50.5 -312.5t-61.5 -334l-68 -343h-164l54 242l61 269l61 279q31 140 55 269l-323 -578h-148q-4 76 -9 155t-12 155l-15 144l-13 124l-72 -282l-73 -279l-71 -264 l-62 -234h-160z" />
<glyph unicode="N" d="M82 0l305 1268h166l81 -271q34 -117 61.5 -226t51 -226t50.5 -271l235 994h154l-305 -1268h-166q-29 170 -55.5 309.5t-56.5 262l-60 233.5l-64 225l-243 -1030h-154z" />
<glyph unicode="O" d="M164 377q0 76 14.5 173t45 199.5t79.5 201t116.5 175t157 123.5t199.5 47q147 0 239.5 -97t92.5 -306q0 -76 -14.5 -173t-45 -199.5t-78.5 -201t-116 -175t-156 -124t-198 -47.5q-150 0 -243 97.5t-93 306.5zM334 389q0 -145 49 -207.5t137 -62.5q100 0 178 74.5 t131.5 188.5t81 248t27.5 251q0 143 -48 206.5t-134 63.5q-100 0 -179 -75t-132.5 -188.5t-82 -247.5t-28.5 -251z" />
<glyph unicode="P" d="M111 0l297 1249q27 6 67 12l86 10q45 5 89 7t81 2q168 0 272.5 -79t104.5 -234q0 -111 -41 -202t-117 -155.5t-180 -100.5t-231 -36h-148l-115 -473h-165zM424 616h137q182 0 280.5 88.5t98.5 245.5q0 51 -20.5 87t-54.5 58.5t-75.5 32t-84.5 9.5q-47 0 -90.5 -2 t-65.5 -7z" />
<glyph unicode="Q" d="M164 377q0 76 14.5 173t45 199.5t79.5 201t116.5 175t157 123.5t199.5 47q147 0 239.5 -97t92.5 -306q0 -72 -12.5 -164t-40 -189.5t-70.5 -192.5t-103.5 -172t-140 -130t-178.5 -68v-14q0 -66 78 -107.5t205 -58.5l-74 -135q-74 14 -144.5 33.5t-123.5 54.5t-85 89.5 t-32 140.5v10q-102 29 -162.5 124t-60.5 263zM334 389q0 -145 49 -207.5t137 -62.5q100 0 178 74.5t131.5 188.5t81 248t27.5 251q0 143 -48 206.5t-134 63.5q-100 0 -179 -75t-132.5 -188.5t-82 -247.5t-28.5 -251z" />
<glyph unicode="R" d="M92 0l297 1249q33 8 73 14.5t81 9.5t81 5t72 2q201 0 293 -83t92 -220q0 -174 -92 -286.5t-244 -160.5l51 -106q24 -51 44 -111.5t40.5 -136.5t43.5 -176h-172q-23 109 -44.5 185.5t-42 133t-40.5 98.5l-41 83h-205l-121 -500h-166zM412 639h102q82 0 154.5 13.5t127 49 t86 96t31.5 152.5q0 98 -63.5 142.5t-165.5 44.5q-47 0 -91 -2t-65 -7z" />
<glyph unicode="S" d="M111 63l77 140q35 -23 109 -52.5t190 -29.5q55 0 109.5 12t97.5 40t68.5 74t25.5 113q0 45 -17 79t-47 61.5t-70 51t-87 48.5q-43 23 -84 49.5t-71.5 62.5t-50 86t-19.5 122q0 166 115.5 271t351.5 105q51 0 100 -8t89 -20.5t71 -25.5t47 -23l-80 -136q-31 27 -98.5 46.5 t-159.5 19.5q-57 0 -105 -12.5t-84 -38t-56.5 -66.5t-20.5 -96q0 -47 14.5 -80t39 -57.5t60.5 -44.5l79 -43l100 -57q47 -28 81 -65.5t53 -88.5t19 -123q0 -100 -35.5 -176t-100 -126t-154.5 -76t-201 -26q-141 0 -231 32.5t-125 57.5z" />
<glyph unicode="T" d="M311 1124l35 144h860l-35 -144h-346l-270 -1124h-170l272 1124h-346z" />
<glyph unicode="U" d="M166 324q0 61 16 131l195 813h168l-195 -811q-16 -70 -16 -129q0 -43 9 -81t29.5 -66.5t54.5 -45t83 -16.5q55 0 100 13t82 48t65.5 96.5t53.5 157.5l201 834h168l-205 -854q-25 -104 -60.5 -186.5t-92 -138.5t-138.5 -86t-199 -30q-84 0 -143 29t-99 77t-58.5 111.5 t-18.5 133.5z" />
<glyph unicode="V" d="M279 1268h176q2 -365 16 -643.5t29 -477.5l287 538q144 273 286 583h180l-99 -203l-162 -312l-202 -372l-221 -381h-209q-20 184 -35.5 381t-25.5 372t-15 312t-5 203z" />
<glyph unicode="W" d="M121 0q12 131 34.5 281.5t51.5 313.5l61 333l66 340h166l-55 -238l-61 -272l-63 -284l-59 -269l71 128l83 147l86 155l84 151h145q4 -70 10.5 -148.5l13.5 -156.5l13 -149q6 -72 12 -127l76 271l77 280l72 270l62 242h162l-185 -628q-94 -308 -215 -640h-155l-47 633 l-348 -633h-158z" />
<glyph unicode="X" d="M18 0l557 676l-215 592h185l160 -461l182 230q88 116 166 231h192q-104 -152 -230 -306l-247 -296q29 -74 58.5 -159t56 -172t49 -173t39.5 -162h-176q-27 131 -65 263t-85 263l-426 -526h-201z" />
<glyph unicode="Y" d="M301 1268h168q18 -166 63.5 -343t92.5 -325l125 166l123 173l116 171l103 158h182q-123 -201 -273.5 -398.5t-316.5 -394.5l-115 -475h-168l113 471q-76 205 -130 400.5t-83 396.5z" />
<glyph unicode="Z" d="M74 0l32 139l202 255l213 257l215 248l206 225h-575l34 144h770l-32 -142l-198 -214l-228 -258l-226 -267q-109 -133 -188 -244h623l-33 -143h-815z" />
<glyph unicode="[" d="M201 -338l426 1770h493l-33 -134h-331l-363 -1503h334l-35 -133h-491z" />
<glyph unicode="\" d="M449 1432h169l142 -1770h-172z" />
<glyph unicode="]" d="M51 -338l31 133h334l362 1503h-334l33 134h492l-426 -1770h-492z" />
<glyph unicode="^" d="M223 657l490 611h145l199 -627l-139 -61l-162 512l-408 -510z" />
<glyph unicode="_" d="M-55 -338l35 143h915l-35 -143h-915z" />
<glyph unicode="`" d="M535 1311l122 104l234 -293l-90 -80z" />
<glyph unicode="a" d="M145 317q0 123 41 240t124 209t208 148.5t291 56.5q25 0 56.5 -2t64.5 -8.5t64.5 -15.5t56.5 -21l-140 -574q-10 -43 -17 -81t-7 -81t8 -85t25 -93l-150 -20q-10 20 -18.5 43.5t-12.5 52.5q-41 -37 -113.5 -73t-170.5 -36q-160 0 -235 96.5t-75 243.5zM315 336 q0 -47 8.5 -87t28 -68.5t53 -46t84.5 -17.5q78 0 138.5 32.5t101.5 77.5q2 31 7 70t14 74l112 448q-10 4 -38.5 7t-45.5 3q-104 0 -189 -40.5t-146.5 -109.5t-94.5 -158t-33 -185z" />
<glyph unicode="b" d="M129 37l324 1354l176 28l-121 -506q43 27 98.5 43.5t116.5 16.5q80 0 138.5 -25.5t96 -69.5t57 -105.5t19.5 -133.5q0 -127 -40 -246t-121.5 -211t-205.5 -147t-290 -55q-55 0 -127 13t-121 44zM317 137q41 -10 91 -10q104 0 189 41t144.5 109.5t92 157.5t32.5 186 q0 41 -8 78.5t-29.5 66.5t-57.5 46t-91 17t-110.5 -18t-102.5 -53z" />
<glyph unicode="c" d="M145 340q0 125 42 239.5t123 202.5t199 140.5t271 52.5q84 0 147.5 -11.5t119.5 -33.5l-64 -144q-35 16 -83 30.5t-134 14.5q-104 0 -188 -39.5t-142.5 -106t-89.5 -151.5t-31 -178q0 -47 12.5 -89t45.5 -74.5t89 -51t142 -18.5q45 0 88 6t80 16.5t64.5 20.5t42.5 20 l14 -143q-37 -23 -120 -45.5t-200 -22.5q-213 0 -320.5 102.5t-107.5 262.5z" />
<glyph unicode="d" d="M164 317q0 123 41 241t123 209t204.5 147.5t284.5 56.5q47 0 94 -6l103 426l174 28l-258 -1069q-10 -43 -17.5 -81t-7.5 -81t8.5 -85t24.5 -93l-150 -20q-10 18 -18 42.5t-12 53.5q-41 -37 -109.5 -73t-173.5 -36q-160 0 -235.5 94t-75.5 246zM334 336q0 -47 8 -87 t27.5 -68.5t53.5 -46t85 -17.5q78 0 138.5 32.5t101.5 77.5q2 31 7 70t13 74l113 448q-10 4 -40 7t-46 3q-104 0 -189.5 -40.5t-146 -109.5t-93 -158t-32.5 -185z" />
<glyph unicode="e" d="M145 332q0 129 40 245.5t116 203.5t183.5 139.5t242.5 52.5q80 0 137.5 -19.5t94 -51.5t54 -75t17.5 -90q0 -129 -65.5 -200.5t-170 -107.5t-232.5 -46t-251 -14q-2 -17 -1 -34q0 -104 69 -154q80 -58 211 -58q43 0 89 7t86 16.5t70.5 20.5t43.5 19l14 -143 q-39 -20 -127 -44t-227 -24q-100 0 -174 30t-123 79t-73 113.5t-24 134.5zM332 500q123 2 221 11t166.5 33.5t105.5 68.5t37 112q0 16 -7 34.5t-24.5 35t-48 26.5t-75.5 10q-70 0 -130.5 -27.5t-109.5 -73.5t-83 -105t-52 -125z" />
<glyph unicode="f" d="M18 -311l39 141q43 -27 119 -27q82 0 127 63.5t68 168.5l164 774h-205l35 141h200l19 86q39 184 138 283.5t296 99.5q63 0 120.5 -12t86.5 -29l-68 -135q-16 8 -50 19.5t-106 11.5q-59 0 -101 -17.5t-71.5 -49t-47 -76t-29.5 -97.5l-19 -84h385l-35 -141h-378l-166 -772 q-23 -102 -52.5 -175t-74.5 -119t-109.5 -66.5t-152.5 -20.5q-31 0 -70 8.5t-62 24.5z" />
<glyph unicode="g" d="M43 -270l66 141q41 -31 110.5 -51.5t147.5 -20.5q152 0 234.5 66.5t109.5 197.5l8 35q-37 -20 -103.5 -39.5t-132.5 -19.5q-150 0 -228.5 73.5t-78.5 206.5q0 123 40 240t122 209t205 147.5t286 55.5q25 0 60 -2t70.5 -7.5t69.5 -14.5t58 -23l-210 -842q-25 -98 -60 -177 t-95 -134.5t-154.5 -85t-237.5 -29.5q-78 0 -156 20.5t-131 53.5zM344 352q0 -98 43 -136t133 -38q37 0 72 8.5t66.5 20.5t57 25.5t42.5 25.5l133 561q-18 4 -46 7t-50 3q-98 0 -181.5 -40.5t-143.5 -108.5t-93 -154t-33 -174z" />
<glyph unicode="h" d="M92 0l332 1391l176 28l-117 -483q41 16 88 25.5t95 9.5q82 0 141 -22.5t96 -62.5t54.5 -95.5t17.5 -120.5q0 -43 -8.5 -90.5t-20.5 -96.5l-117 -483h-167l106 446l26 106q13 54 13 103q0 72 -41 120t-150 48q-92 0 -163 -28l-195 -795h-166z" />
<glyph unicode="i" d="M274 809l33 141h443l-125 -530q-10 -41 -17.5 -78t-7.5 -72q0 -57 29.5 -95t113.5 -38q35 0 68 5t61 14l-10 -144q-14 -4 -52 -11t-108 -7q-76 0 -128 20.5t-83.5 55t-45 82t-13.5 102.5q0 43 7 88t18 92l92 375h-275zM553 1219q0 72 45 112.5t100 40.5q53 0 89 -32.5 t36 -92.5q0 -35 -13 -61.5t-34.5 -47t-47.5 -30.5t-52 -10q-53 0 -88 31t-35 90z" />
<glyph unicode="j" d="M43 -270l66 141q20 -16 47.5 -28.5t58.5 -21.5t61.5 -14.5t57.5 -5.5q106 0 163.5 47.5t86.5 167.5l192 793h-385l33 141h553l-225 -938q-47 -197 -158 -276.5t-279 -79.5q-153 0 -272 74zM754 1219q0 72 45 112.5t100 40.5q53 0 89 -32.5t36 -92.5q0 -35 -13.5 -61.5 t-34 -47t-47 -30.5t-52.5 -10q-53 0 -88 31t-35 90z" />
<glyph unicode="k" d="M129 0l334 1391l176 28l-207 -852l251 190q128 99 232 193h201q-51 -53 -120 -112l-141 -118l-142 -112l-123 -92q47 -41 97 -100.5t96 -129t86 -143t65 -143.5h-182q-66 147 -154 272t-186 203l-115 -475h-168z" />
<glyph unicode="l" d="M367 1266l34 143h443l-246 -1022q-10 -41 -16.5 -79t-6.5 -70q0 -59 29 -88t107 -29q53 0 104 18.5t80 34.5l12 -143q-29 -16 -93 -35t-150 -19q-135 0 -195.5 58.5t-60.5 175.5q0 84 26 190l207 865h-274z" />
<glyph unicode="m" d="M63 0l222 924q129 47 235 47q57 0 101.5 -17.5t70.5 -52.5q100 70 197 70q47 0 85 -18.5t61.5 -55.5t29.5 -92q2 -14 1 -29q0 -45 -13 -100l-160 -676h-154l162 680q9 35 9 62q0 30 -11 51q-20 39 -68 38q-51 0 -104 -51q0 -23 -2 -49t-10 -55l-74 -309h-154l76 311 q11 43 11 75q0 21 -5 38q-12 41 -71 40q-37 0 -86 -18l-197 -813h-152z" />
<glyph unicode="n" d="M129 0l219 915q84 25 180.5 40.5t173.5 15.5q82 0 141.5 -22.5t96.5 -62.5t54.5 -95.5t17.5 -120.5q0 -43 -8.5 -89t-20.5 -94l-117 -487h-168l109 451l24 103q12 52 13 101q0 72 -41 120t-150 48q-47 0 -91 -5t-73 -15l-192 -803h-168z" />
<glyph unicode="o" d="M164 309q0 106 29.5 223t96 215.5t171 162t252.5 63.5q152 0 236.5 -88t84.5 -244q0 -106 -29.5 -223t-96 -215.5t-171 -162t-252.5 -63.5q-152 0 -236.5 88t-84.5 244zM334 324q0 -92 41 -143.5t139 -51.5q82 0 147.5 46t110.5 118t68.5 161t23.5 173q0 92 -41 144 t-139 52q-82 0 -147.5 -46t-110.5 -118.5t-68.5 -161.5t-23.5 -173z" />
<glyph unicode="p" d="M37 -338l299 1249q37 14 83 26.5t93 20t93 11.5t85 4q88 0 153.5 -25.5t107.5 -69.5t62.5 -105.5t20.5 -133.5q0 -127 -38 -246t-117.5 -211t-201.5 -148.5t-288 -56.5q-20 0 -54 5.5t-52 9.5l-78 -330h-168zM319 139q18 -4 48 -7t51 -3q104 0 187 40t141.5 107.5 t89 156.5t30.5 185q0 41 -9 79t-33.5 68t-67.5 47t-109 17q-45 0 -92 -8t-74 -14z" />
<glyph unicode="q" d="M164 317q0 123 41 240t124 209t208 148.5t290 56.5q25 0 59 -3t69.5 -9.5t67.5 -14.5t54 -20l-313 -1262h-168l88 369q-43 -23 -96 -38.5t-113 -15.5q-160 0 -235.5 94t-75.5 246zM334 336q0 -41 7 -80t26.5 -69.5t56.5 -50t96 -19.5q53 0 107.5 22.5t99.5 57.5l152 622 q-25 4 -47.5 7t-38.5 3q-104 0 -189.5 -40.5t-145 -109.5t-92 -158t-32.5 -185z" />
<glyph unicode="r" d="M182 0l217 901q217 70 437 70q63 0 112 -5t121 -20l-63 -149q-31 8 -56.5 13t-48 8t-46.5 4t-54 1q-63 0 -130 -8t-132 -24l-189 -791h-168z" />
<glyph unicode="s" d="M162 51l67 144q33 -23 102.5 -49.5t164.5 -26.5q45 0 89 7t78.5 23.5t56 45t21.5 69.5q0 57 -48 90t-134 74l-80 41q-39 20 -68.5 47t-48 64.5t-18.5 91.5q0 137 106.5 219t301.5 82q96 0 166.5 -16.5t105.5 -34.5l-63 -144q-31 18 -93.5 34.5t-140.5 16.5q-41 0 -81 -7 t-70.5 -23.5t-49 -43t-18.5 -67.5q0 -49 50 -83t126 -66q47 -18 88 -41t70.5 -52.5t46 -68.5t16.5 -92q0 -78 -30.5 -136.5t-86 -96.5t-132 -57.5t-169.5 -19.5q-117 0 -201.5 26.5t-123.5 49.5z" />
<glyph unicode="t" d="M283 809l32 141h203l64 267l176 28l-72 -295h365l-33 -141h-367l-96 -408q-10 -39 -18.5 -75.5t-8.5 -71.5q0 -78 36 -103.5t102 -25.5q63 0 123.5 13.5t113.5 33.5l-4 -145q-59 -20 -123.5 -35t-136.5 -15q-59 0 -109.5 12.5t-88.5 40t-59.5 75t-21.5 118.5 q0 45 7.5 94.5t19.5 100.5l96 391h-200z" />
<glyph unicode="u" d="M172 276q0 47 8 94.5t19 94.5l116 485h170l-108 -448l-24 -100q-13 -56 -13 -113q0 -33 6 -62.5t22.5 -53t45 -37t73.5 -13.5q78 0 139.5 33.5t100.5 79.5q2 29 5 60.5t13 68.5l142 585h168l-144 -600q-10 -43 -16 -82t-6 -82t7 -84t26 -92l-150 -20q-10 20 -19.5 45.5 t-13.5 54.5q-41 -37 -110.5 -73.5t-173.5 -36.5q-80 0 -133.5 23.5t-87 63.5t-48 94t-14.5 115z" />
<glyph unicode="v" d="M274 950h172q2 -90 8.5 -191.5t16.5 -202.5t22.5 -195.5t26.5 -170.5q55 70 113.5 164.5t114 196.5t100.5 206.5t74 192.5h172q-41 -121 -102.5 -250t-134.5 -255t-151.5 -240.5t-154.5 -204.5h-156q-45 188 -80 437t-41 513z" />
<glyph unicode="w" d="M164 0q4 252 24.5 498.5t49.5 451.5h159q-14 -80 -25.5 -157.5t-21.5 -164.5t-20.5 -189.5t-20.5 -231.5l89 150l71 121l63 113l70 128h119q2 -74 6 -129t9 -109.5t12.5 -115t13.5 -146.5q86 199 149.5 382t114.5 349h158l-77 -220l-90 -241l-102 -247 q-53 -125 -108 -242h-139q-10 61 -18 118l-14 114q-7 58 -13.5 122t-12.5 142l-87 -148l-72 -120l-70 -110l-78 -118h-139z" />
<glyph unicode="x" d="M37 0l477 489l-235 461h188l164 -340l87 97l85 95l74 84q33 38 51 64h182q-12 -16 -42 -52l-69 -81l-83 -95l-85 -95l-74 -83l-52 -59l114 -233q55 -117 103 -252h-179q-37 100 -72.5 184t-80.5 176l-357 -360h-196z" />
<glyph unicode="y" d="M-37 -303l60 139q16 -16 47.5 -25.5t70.5 -9.5q106 0 178 43t142 144q-68 223 -119 466.5t-61 495.5h172q2 -82 12 -180t27.5 -202.5t40 -211t47.5 -202.5q70 111 126 228.5t99 225t72.5 197.5t42.5 145h178q-20 -70 -57 -173t-89.5 -223t-118 -246t-141.5 -238 q-57 -86 -115.5 -162t-125 -132.5t-147.5 -88t-181 -31.5q-51 0 -94 12.5t-66 28.5z" />
<glyph unicode="z" d="M119 0l26 111q55 80 139 177l174 194l179 184q88 86 154 143h-453l37 141h667l-30 -121l-144 -134l-187 -187l-187 -198q-90 -97 -144 -167h512l-33 -143h-710z" />
<glyph unicode="{" d="M182 481l33 131h84q41 0 75 15.5t60.5 41t44 57.5t25.5 65l78 329q20 84 49.5 143.5t79 96.5t119 54.5t169.5 17.5h172l-34 -134h-164q-49 0 -88 -6t-66.5 -25.5t-48 -55t-33.5 -93.5l-67 -282q-29 -121 -73 -188.5t-120 -100.5q39 -33 56.5 -75t17.5 -89q0 -33 -6 -64 l-13 -61l-67 -283q-12 -53 -12 -82q0 -59 37.5 -78.5t119.5 -19.5h172l-34 -133h-179q-133 0 -203.5 46t-70.5 157q0 51 14 108l78 330q8 27 8 53q0 51 -29.5 88t-101.5 37h-82z" />
<glyph unicode="|" d="M313 -338l426 1770h160l-426 -1770h-160z" />
<glyph unicode="}" d="M0 -338l33 133h164q51 0 89 6t66.5 25.5t49 55.5t32.5 93l68 283q29 121 71.5 188.5t118.5 100.5q-39 33 -55 75t-16 89q0 33 5 63.5t13 61.5l68 282q4 27 8 46.5t4 35.5q0 59 -38 78.5t-122 19.5h-172l35 134h180q133 0 204 -46.5t71 -156.5q0 -23 -4.5 -50.5 t-10.5 -58.5l-80 -329q-6 -31 -6 -54q0 -51 29 -88t100 -37h82l-33 -131h-82q-41 0 -75.5 -15t-60 -41t-43 -57.5t-25.5 -64.5l-78 -330q-20 -84 -51 -143t-79 -96t-119 -54.5t-169 -17.5h-172z" />
<glyph unicode="~" d="M154 434q14 39 38.5 84t61.5 84t85 63.5t112 24.5q66 0 105.5 -24.5t74.5 -51.5q43 -29 75.5 -53t81.5 -24q31 0 54.5 14t43 35.5t34 46t24.5 47.5l117 -37q-14 -41 -39 -85t-61.5 -83t-85 -63.5t-111.5 -24.5q-66 0 -106 25.5t-74 50.5l-75 54q-34 24 -83 24 q-31 0 -55.5 -14.5t-43 -36t-32.5 -47l-25 -46.5z" />
<glyph unicode="&#xa0;" />
<glyph unicode="&#xa2;" d="M195 412q0 98 31.5 195.5t95 178t155.5 139t215 79.5l62 264h147l-59 -254q53 -4 104 -13.5t98 -31.5l-61 -135q-33 16 -76 25t-108 9q-98 0 -179 -38.5t-138.5 -102t-89.5 -144.5t-32 -165q0 -45 12.5 -84t44.5 -68.5t85 -47t133 -17.5q35 0 72.5 6t71.5 14t59.5 18.5 t35.5 20.5l13 -141q-33 -20 -107.5 -39t-171.5 -23l-59 -256h-148l62 265q-135 33 -201.5 116t-66.5 230z" />
<glyph unicode="&#xa3;" d="M180 0l98 259q46 128 76 259l8 27h-169l32 137h170l37 152q33 137 77 226t103.5 140t134 70.5t169 19.5t147.5 -17.5t94 -39.5l-76 -137q-43 23 -88 35t-100 12q-53 0 -97 -15.5t-80 -50.5t-64.5 -93t-49.5 -146l-37 -156h346l-32 -137h-347l-4 -15q-23 -92 -54.5 -192 t-67.5 -193h530l-35 -145h-721z" />
<glyph unicode="&#xa5;" d="M152 195l30 129h297l43 186h-295l31 131h248q-66 164 -113 312.5t-92 314.5h178q29 -150 75 -295.5t93 -267.5l218 274t204 289h193q-117 -164 -238 -316l-258 -311h252l-33 -131h-293l-45 -186h295l-31 -129h-295l-47 -195h-168l48 195h-297z" />
<glyph unicode="&#xa9;" d="M145 473q0 125 39 219t101.5 156.5t142.5 93.5t162 31t161.5 -31t142 -93.5t100.5 -155.5t38 -216q0 -125 -39 -218t-101.5 -155.5t-142 -94.5t-161.5 -32q-84 0 -163 32t-141.5 93.5t-100.5 154.5t-38 216zM264 477q0 -98 27.5 -171t74 -121t104.5 -72.5t119.5 -24.5 t119 24.5t103.5 72.5t73.5 120t27.5 168q0 98 -27.5 171t-73.5 121t-104.5 72.5t-117.5 24.5q-61 0 -119.5 -24.5t-105 -72.5t-74 -121t-27.5 -167zM367 469q0 49 14 96t43 84t74 59.5t106 22.5q31 0 67 -5t72 -21l-43 -111q-23 10 -44 13t-42 3q-63 0 -90.5 -41t-27.5 -92 q0 -66 32.5 -103.5t96.5 -37.5q16 0 40.5 4t45.5 14l34 -108q-35 -16 -72.5 -24.5t-70.5 -8.5q-59 0 -103 21.5t-74 57.5t-44 82t-14 95z" />
<glyph unicode="&#xad;" d="M360 440l39 160h449l-37 -160h-451z" />
<glyph unicode="&#xae;" d="M145 473q0 125 39 219t101.5 156.5t142.5 93.5t162 31t161.5 -31t142 -93.5t100.5 -155.5t38 -216q0 -125 -39 -218t-101.5 -155.5t-142 -94.5t-161.5 -32q-84 0 -163 32t-141.5 93.5t-100.5 154.5t-38 216zM264 477q0 -98 27.5 -171t74 -121t104.5 -72.5t119.5 -24.5 t119 24.5t103.5 72.5t73.5 120t27.5 168q0 98 -27.5 171t-73.5 121t-104.5 72.5t-117.5 24.5q-61 0 -119.5 -24.5t-105 -72.5t-74 -121t-27.5 -167zM418 225v488q27 8 62.5 13t74.5 5q117 0 172 -45t55 -131q0 -100 -80 -145q23 -35 50.5 -83t54.5 -102h-117l-48 87l-40 71 h-76v-158h-108zM526 485h39q55 0 82 14.5t27 61.5q0 41 -33 54.5t-68 13.5q-14 0 -25 -1t-22 -3v-140z" />
<glyph unicode="&#xb4;" d="M625 1139l288 276l93 -133l-310 -233z" />
<glyph unicode="&#x2000;" horiz-adv-x="727" />
<glyph unicode="&#x2001;" horiz-adv-x="1454" />
<glyph unicode="&#x2002;" horiz-adv-x="727" />
<glyph unicode="&#x2003;" horiz-adv-x="1454" />
<glyph unicode="&#x2004;" horiz-adv-x="483" />
<glyph unicode="&#x2005;" horiz-adv-x="362" />
<glyph unicode="&#x2006;" horiz-adv-x="241" />
<glyph unicode="&#x2007;" horiz-adv-x="241" />
<glyph unicode="&#x2008;" horiz-adv-x="180" />
<glyph unicode="&#x2009;" horiz-adv-x="290" />
<glyph unicode="&#x200a;" horiz-adv-x="79" />
<glyph unicode="&#x2010;" d="M360 440l39 160h449l-37 -160h-451z" />
<glyph unicode="&#x2011;" d="M360 440l39 160h449l-37 -160h-451z" />
<glyph unicode="&#x2012;" d="M360 440l39 160h449l-37 -160h-451z" />
<glyph unicode="&#x2013;" d="M205 483l35 144h743l-35 -144h-743z" />
<glyph unicode="&#x2014;" d="M74 483l32 144h1024l-34 -144h-1022z" />
<glyph unicode="&#x2018;" d="M543 1042q0 57 25.5 124t77.5 126.5t134 103.5t195 58l14 -131q-35 -4 -72.5 -14.5t-71.5 -27.5t-61.5 -44t-40.5 -63q51 -8 78 -47.5t27 -88.5q0 -70 -44 -117t-120 -47q-70 0 -105.5 48t-35.5 120z" />
<glyph unicode="&#x2019;" d="M487 999q35 4 72 14.5t71 28t61.5 44t39.5 63.5q-49 8 -76.5 47t-27.5 88q0 70 45 117t121 47q68 0 103.5 -48t35.5 -120q0 -59 -24.5 -124.5t-77 -125t-134.5 -103.5t-194 -59z" />
<glyph unicode="&#x201c;" d="M317 1071q0 51 22.5 106.5t66 104.5t109 86t151.5 51l28 -119l-66 -15q-32 -7 -59.5 -21.5t-49 -36t-34.5 -58.5q55 -4 85 -45t30 -90q0 -51 -34 -93t-101 -42q-59 0 -103.5 41t-44.5 131zM795 1071q0 51 21.5 106.5t65.5 104.5t108.5 86t150.5 51l30 -119l-67 -15 q-33 -7 -60.5 -21.5t-49 -36t-33.5 -58.5q55 -4 84.5 -45t29.5 -90q0 -51 -32.5 -93t-102.5 -42q-59 0 -102 41t-43 131z" />
<glyph unicode="&#x201d;" d="M291 1018q35 6 66.5 14t59 21.5t50 36t35.5 59.5q-57 4 -87 45t-30 88q0 51 34 93t103 42q59 0 102.5 -41t43.5 -131q0 -51 -21.5 -106.5t-65.5 -104.5t-109.5 -86t-152.5 -51zM766 1018q35 6 66.5 14t59.5 21.5t50.5 36t34.5 59.5q-57 4 -86 45t-29 88q0 51 33 93 t102 42q59 0 102.5 -41t43.5 -131q0 -51 -21.5 -106.5t-65.5 -104.5t-109.5 -86t-151.5 -51z" />
<glyph unicode="&#x2022;" d="M338 586q0 57 19.5 110.5t55.5 94t87 64.5t116 24q63 0 115.5 -24t88.5 -64.5t55.5 -94t19.5 -110.5q0 -59 -19.5 -112.5t-55.5 -93.5t-88 -63.5t-116 -23.5q-66 0 -116.5 23.5t-86.5 63.5t-55.5 93.5t-19.5 112.5z" />
<glyph unicode="&#x2026;" d="M49 72q0 59 34 92t81 33q41 0 69.5 -26t28.5 -75q0 -55 -37 -88t-80 -33q-41 0 -68.5 25t-27.5 72zM389 72q0 59 34 92t81 33q41 0 69.5 -26t28.5 -75q0 -55 -37 -88t-80 -33q-41 0 -68.5 25t-27.5 72zM733 72q0 59 34 92t81 33q41 0 69.5 -26t28.5 -75q0 -55 -37 -88 t-80 -33q-41 0 -68.5 25t-27.5 72z" />
<glyph unicode="&#x202f;" horiz-adv-x="290" />
<glyph unicode="&#x205f;" horiz-adv-x="362" />
<glyph unicode="&#x20ac;" d="M117 416l30 131h148q4 45 14 91t23 93h-142l31 131h154q37 90 90 168t126 136.5t165 91t207 32.5q72 0 122 -10t97 -31l-68 -137q-29 16 -65.5 25.5t-108.5 9.5t-130 -21.5t-106.5 -60.5t-86 -90t-64.5 -113h432l-53 -131h-428q-16 -45 -25.5 -92t-13.5 -92h393l-51 -131 h-354v-33q0 -78 19.5 -128t52 -79t77.5 -41t96 -12q84 0 141.5 14.5t102.5 36.5l6 -145q-12 -6 -39.5 -15.5t-64.5 -17.5t-80 -14.5t-86 -6.5q-193 0 -293 99.5t-100 298.5v43h-168z" />
<glyph unicode="&#x2122;" d="M240 1165v103h383v-103h-134v-434h-118v434h-131zM659 731q6 102 12.5 178t13.5 137.5t14.5 113.5t17.5 108h110l91 -279l98 279h108q10 -55 17.5 -108.5t13.5 -115t11 -137.5l12 -176h-119q0 8 -1 53t-2 104l-2 120q-1 61 -3 102l-88 -238h-93l-79 238 q-4 -41 -6.5 -102.5t-3.5 -120t-2 -103.5t-1 -53h-119z" />
<glyph unicode="&#xe000;" horiz-adv-x="950" d="M0 950h950v-950h-950v950z" />
</font>
</defs></svg>
Side by side

After

Width:  |  Height:  |  Size: 32 KiB

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-RI-webfont.ttf Executable file
View file

Binary file not shown.

BIN
mps/manual/html/_static/font/ubuntu-mono/UbuntuMono-RI-webfont.woff Executable file
View file

Binary file not shown.

48
mps/manual/html/_static/font/ubuntu-mono/demo.html Executable file
View file

@ -0,0 +1,48 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
<title>Font Face Demo</title>
<link rel="stylesheet" href="stylesheet.css" type="text/css" charset="utf-8">
<style type="text/css" media="screen">
h1.fontface {font: 60px/68px 'UbuntuMonoRegular', Arial, sans-serif;letter-spacing: 0;}
p.style1 {font: 18px/27px 'UbuntuMonoRegular', Arial, sans-serif;}
p.style2 {font: 18px/27px 'UbuntuMonoItalic', Arial, sans-serif;}
p.style3 {font: 18px/27px 'UbuntuMonoBold', Arial, sans-serif;}
p.style4 {font: 18px/27px 'UbuntuMonoBoldItalic', Arial, sans-serif;}
#container {
width: 800px;
margin-left: auto;
margin-right: auto;
}
</style>
</head>
<body>
<div id="container">
<h1 class="fontface">Font-face Demo for the Ubuntu Mono Font</h1>
<p class="style1">Ubuntu Mono Regular - Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
<p class="style2">Ubuntu Mono Italic - Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
<p class="style3">Ubuntu Mono Bold - Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
<p class="style4">Ubuntu Mono Bold Italic - Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
</div>
</body>
</html>

52
mps/manual/html/_static/font/ubuntu-mono/stylesheet.css Executable file
View file

@ -0,0 +1,52 @@
/* Generated by Font Squirrel (http://www.fontsquirrel.com) on June 5, 2013 08:15:09 PM America/New_York */
@font-face {
font-family: 'UbuntuMonoRegular';
src: url('UbuntuMono-R-webfont.eot');
src: url('UbuntuMono-R-webfont.eot?#iefix') format('embedded-opentype'),
url('UbuntuMono-R-webfont.woff') format('woff'),
url('UbuntuMono-R-webfont.ttf') format('truetype'),
url('UbuntuMono-R-webfont.svg#UbuntuMonoRegular') format('svg');
font-weight: normal;
font-style: normal;
}
@font-face {
font-family: 'UbuntuMonoItalic';
src: url('UbuntuMono-RI-webfont.eot');
src: url('UbuntuMono-RI-webfont.eot?#iefix') format('embedded-opentype'),
url('UbuntuMono-RI-webfont.woff') format('woff'),
url('UbuntuMono-RI-webfont.ttf') format('truetype'),
url('UbuntuMono-RI-webfont.svg#UbuntuMonoItalic') format('svg');
font-weight: normal;
font-style: normal;
}
@font-face {
font-family: 'UbuntuMonoBold';
src: url('UbuntuMono-B-webfont.eot');
src: url('UbuntuMono-B-webfont.eot?#iefix') format('embedded-opentype'),
url('UbuntuMono-B-webfont.woff') format('woff'),
url('UbuntuMono-B-webfont.ttf') format('truetype'),
url('UbuntuMono-B-webfont.svg#UbuntuMonoBold') format('svg');
font-weight: normal;
font-style: normal;
}
@font-face {
font-family: 'UbuntuMonoBoldItalic';
src: url('UbuntuMono-BI-webfont.eot');
src: url('UbuntuMono-BI-webfont.eot?#iefix') format('embedded-opentype'),
url('UbuntuMono-BI-webfont.woff') format('woff'),
url('UbuntuMono-BI-webfont.ttf') format('truetype'),
url('UbuntuMono-BI-webfont.svg#UbuntuMonoBoldItalic') format('svg');
font-weight: normal;
font-style: normal;
}

114
mps/manual/html/_static/mps.css
View file

@ -3,16 +3,66 @@
@import url('default.css');
/* See <http://www.paulirish.com/2009/bulletproof-font-face-implementation-syntax/> */
@font-face {
font-family: 'SCP';
font-weight: bold;
src: url('SourceCodePro-Bold.ttf');
font-family: "Ubuntu Mono";
src: url("font/ubuntu-mono/UbuntuMono-R-webfont.eot");
src: url("font/ubuntu-mono/UbuntuMono-R-webfont.eot?#iefix")
format("embedded-opentype"),
url("font/ubuntu-mono/UbuntuMono-R-webfont.woff")
format("woff"),
url("font/ubuntu-mono/UbuntuMono-R-webfont.ttf")
format("truetype"),
url("font/ubuntu-mono/UbuntuMono-R-webfont.svg#UbuntuMonoRegular")
format("svg");
font-weight: normal;
font-style: normal;
}
@font-face {
font-family: 'SCP';
font-weight: normal;
src: url('SourceCodePro-Regular.ttf');
font-family: "Ubuntu Mono";
src: url("font/ubuntu-mono/UbuntuMono-RI-webfont.eot");
src: url("font/ubuntu-mono/UbuntuMono-RI-webfont.eot?#iefix")
format("embedded-opentype"),
url("font/ubuntu-mono/UbuntuMono-RI-webfont.woff")
format("woff"),
url("font/ubuntu-mono/UbuntuMono-RI-webfont.ttf")
format("truetype"),
url("font/ubuntu-mono/UbuntuMono-RI-webfont.svg#UbuntuMonoItalic")
format("svg");
font-weight: normal;
font-style: italic;
}
@font-face {
font-family: "Ubuntu Mono";
src: url("font/ubuntu-mono/UbuntuMono-B-webfont.eot");
src: url("font/ubuntu-mono/UbuntuMono-B-webfont.eot?#iefix")
format("embedded-opentype"),
url("font/ubuntu-mono/UbuntuMono-B-webfont.woff")
format("woff"),
url("font/ubuntu-mono/UbuntuMono-B-webfont.ttf")
format("truetype"),
url("font/ubuntu-mono/UbuntuMono-B-webfont.svg#UbuntuMonoBold")
format("svg");
font-weight: bold;
font-style: normal;
}
@font-face {
font-family: "Ubuntu Mono";
src: url("font/ubuntu-mono/UbuntuMono-BI-webfont.eot");
src: url("font/ubuntu-mono/UbuntuMono-BI-webfont.eot?#iefix")
format("embedded-opentype"),
url("font/ubuntu-mono/UbuntuMono-BI-webfont.woff")
format("woff"),
url("font/ubuntu-mono/UbuntuMono-BI-webfont.ttf")
format("truetype"),
url("font/ubuntu-mono/UbuntuMono-BI-webfont.svg#UbuntuMonoBoldItalic")
format("svg");
font-weight: bold;
font-style: italic;
}
a, a:visited, a.reference.internal {
@ -50,13 +100,29 @@ div.bodywrapper {
margin: 0;
}
div.body h1 {
border-bottom: 2px solid #73626E;
}
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 {
border-bottom: none;
}
div.body {
padding: 1em;
}
div.body h1,
div.body h2,
div.body h3,
div.body h4,
div.body h5,
div.body h6 {
border-bottom: 2px solid #73626E;
margin: 0;
padding-left: 0;
}
div.body h1 {
@ -66,15 +132,18 @@ div.body h1 {
dl.glossary dt, dl.type dt, dl.function dt, dl.macro dt {
font-family: 'Verdana', sans-serif;
width:100%;
border-bottom: 1px solid #73626E;
border-bottom: none;
padding-bottom: 1px;
margin-top: 2em;
margin-bottom: 1em;
font-size: 120%;
/* Use a hanging indent so that long wrapped prototypes are easier to read. */
padding-left: 4em;
text-indent: -4em;
}
pre, tt, code, a.mpstag {
font-family: 'SCP', monospaced;
font-family: 'Ubuntu Mono', monospace;
font-size: 100%;
}
@ -88,7 +157,6 @@ tt.xref, a tt {
pre {
border: none;
font-size: 90%;
}
div.seealso, div.admonition {
@ -121,4 +189,28 @@ sup {
div.figure img {
max-width: 100%;
}
}
/* Sphinx justifies body paragraphs by default, but this really doesn't work
when we have technical work with long identifiers mixed with text. */
div.body p, div.body dd, div.body li {
text-align: left;
}
/* Space out list elements a little bit. */
div.body ul li:not(:first-child),
div.body ol li:not(:first-child) {
padding-top: 1.1ex;
}
/* When a <p> is inside an <li> to space it out, reduce that spacing a bit
to compensate for the above. */
div.body li>p:first-child {
margin-top: 0.5ex;
}
div.body li>p:last-child {
margin-bottom: 0.5ex;
}
/* Don't space out the the table of contents. */
li.toctree-l1, li.toctree-l2, li.toctree-l3 {
padding-top: 0 !important;
}

2
mps/manual/html/design/arenavm.html
View file

@ -201,7 +201,7 @@ <h2>3.8. Notes<a class="headerlink" href="#id1" title="Permalink to this headlin
tables.</p>
<p>[missing figure]</p>
<p><span class="target" id="design.mps.arena.vm.fig.count"></span><a class="mpstag reference internal" href="#design.mps.arena.vm.fig.count">.fig.count:</a> How a count table can be used to partially map the page
table, as proposed in request.dylan.170049.sol.map.</p>
table, as proposed in <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170049">request.dylan.170049.sol.map</a>.</p>
<p>[missing figure]</p>
</div>
</div>

18
mps/manual/html/design/bt.html
View file

@ -655,7 +655,7 @@ <h3>4.9.2. Functions<a class="headerlink" href="#functions" title="Permalink to
<span class="pre">``searchLimit</span> <span class="pre">-</span> <span class="pre">searchBase</span></tt>.</p>
<p><span class="target" id="design.mps.bt.fun.find-res-range"></span><a class="mpstag reference internal" href="#design.mps.bt.fun.find-res-range">.fun.find-res-range:</a> <a class="reference internal" href="#BTFindResRange" title="BTFindResRange"><tt class="xref c c-func docutils literal"><span class="pre">BTFindResRange()</span></tt></a>. Iterate within the search
boundaries, identifying candidate ranges by searching for a reset bit.
The <a class="reference internal" href="../mmref/bib.html#bm77"><em>Boyer–Moore algorithm</em></a> is used (it&#8217;s particularly
The Boyer–Moore algorithm <a class="reference internal" href="#boyer-moore-1977">[Boyer_Moore_1977]</a> is used (it&#8217;s particularly
easy to implement when there are only two symbols, 0 and 1, in the
alphabet). For each candidate range, iterate backwards over the bits
from the end of the range towards the beginning. If a set bit is
@ -679,9 +679,9 @@ <h3>4.9.2. Functions<a class="headerlink" href="#functions" title="Permalink to
word or subword.</p>
<p><span class="target" id="design.mps.bt.fun.find-res-range.improve"></span><a class="mpstag reference internal" href="#design.mps.bt.fun.find-res-range.improve">.fun.find-res-range.improve:</a> Various other performance improvements
have been suggested in the past, including some from
request.epcore.170534. Here is a list of potential improvements which
all sound plausible, but which have not led to performance
improvements in practice:</p>
<a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/170534">request.epcore.170534</a>. Here is a list of potential improvements which
all sound plausible, but which have not led to performance improvements
in practice:</p>
<ul class="simple">
<li><span class="target" id="design.mps.bt.fun.find-res-range.improve.step.partial"></span><a class="mpstag reference internal" href="#design.mps.bt.fun.find-res-range.improve.step.partial">.fun.find-res-range.improve.step.partial:</a> When the top index in a
candidate range fails, skip partial words as well as whole words,
@ -725,6 +725,15 @@ <h2>4.10. Testing<a class="headerlink" href="#testing" title="Permalink to this
Tables more extensively. See change.mps.epcore.brisling.160181 TEST1
and TEST2.</p>
</div>
<div class="section" id="references">
<h2>4.11. References<a class="headerlink" href="#references" title="Permalink to this headline"></a></h2>
<table class="docutils citation" frame="void" id="boyer-moore-1977" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id1">[Boyer_Moore_1977]</a></td><td>Robert S. Boyer and J. Strother Moore. Communications of the ACM 20(10):762–772. 1977. &#8220;<a class="reference external" href="http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf">A Fast String Searching Algorithm</a>&#8221;.</td></tr>
</tbody>
</table>
</div>
</div>
@ -753,6 +762,7 @@ <h3><a href="../index.html">Table Of Contents</a></h3>
</ul>
</li>
<li><a class="reference internal" href="#testing">4.10. Testing</a></li>
<li><a class="reference internal" href="#references">4.11. References</a></li>
</ul>
</li>
</ul>

2
mps/manual/html/design/buffer.html
View file

@ -138,7 +138,7 @@ <h2>5.4. Requirements<a class="headerlink" href="#requirements" title="Permalink
<p class="first admonition-title">Note</p>
<p class="last">Actually not a requirement any more, but once was put forward as a
Dylan requirement. Bits of the code still reflect this
requirement. See request.dylan.170554.</p>
requirement. See <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170554">request.dylan.170554</a>.</p>
</div>
</div>
<div class="section" id="classes">

5
mps/manual/html/design/config.html
View file

@ -182,11 +182,6 @@ <h3>1.5.1. Abstract build function<a class="headerlink" href="#abstract-build-fu
<a class="reference internal" href="#design.mps.config.var.hot">.var.hot</a> at the cost of early detection of memory management
bugs. We do not advise use of this variety, as memory management
bugs tend to be extremely expensive to deal with.</div></blockquote>
<p><span class="target" id="design.mps.config.var.diag"></span><a class="mpstag reference internal" href="#design.mps.config.var.diag">.var.diag:</a> <tt class="xref c c-macro docutils literal"><span class="pre">DIAG</span></tt> (deprecated)</p>
<blockquote>
<div>This variety does some client-specific analysis and produces some
specialised diagnostic output, and is not intended for general use.
It will be phased out of the open sources.</div></blockquote>
<p><span class="target" id="design.mps.config.default.hot"></span><a class="mpstag reference internal" href="#design.mps.config.default.hot">.default.hot:</a> If no <tt class="xref c c-macro docutils literal"><span class="pre">CONFIG_VAR</span></tt> is present, <tt class="xref c c-macro docutils literal"><span class="pre">HOT</span></tt> is assumed in
<a class="reference external" href="&lt;../code/config.h&gt;">config.h</a>.</p>
<p><span class="target" id="design.mps.config.build.srcs"></span><a class="mpstag reference internal" href="#design.mps.config.build.srcs">.build.srcs:</a> The &#8220;srcs&#8221; are the set of sources that must be

224
mps/manual/html/design/diag.html
View file

@ -65,12 +65,12 @@ <h3>Navigation</h3>
<div class="section" id="overview">
<h2>9.2. Overview<a class="headerlink" href="#overview" title="Permalink to this headline"></a></h2>
<p>Diagnostic feedback is information created by the MPS diagnostic
system for the purpose of helping MPS programmers client-code
system for the purpose of helping MPS programmers and client
programmers.</p>
<p>Such a piece of information is called &#8220;a diagnostic&#8221;. (See also
<a class="reference internal" href="#design.mps.diag.parts">.parts</a>.)</p>
<p>A diagnostic is not intended to be end-user readable (or visible), or
machine-parseable.</p>
<p>A diagnostic is not intended to be visible to end users, or readable
by them.</p>
<p>A diagnostic is not intended to be stable from one release to the
next: it may be modified or removed at any time.</p>
</div>
@ -83,176 +83,83 @@ <h2>9.3. Requirements<a class="headerlink" href="#requirements" title="Permalink
<li>control (for example, filter) output of diagnostics;</li>
<li>use a channel to get the diagnostic out.</li>
</ul>
<p>Note: the knowledge/code/logic for constructing the human-useful
message is kept inside normal MPS source code. This means it is always
in-sync with changes to the MPS. This also means that any external
utilities used to display the messages do not need to understand, or
keep in sync with, the details of what&#8217;s going inside the MPS.</p>
</div>
<div class="section" id="usage">
<h2>9.4. Usage<a class="headerlink" href="#usage" title="Permalink to this headline"></a></h2>
<p>To run the MPS and get diagnostic output from it:</p>
<ol class="arabic simple">
<li>Use a variety with diagnostics compiled-in. Currently, that means
variety.di. See <tt class="docutils literal"><span class="pre">config.h</span></tt>.</li>
<li>Check that the diagnostics you require are generated, by looking in
MPS source for invocations of the appropriate macro (for example,
<tt class="xref c c-func docutils literal"><span class="pre">DIAG_SINGLEF()</span></tt>).</li>
<li>Check that the diagnostics you require will be output, by looking
at the diagnostic filter rules in <tt class="docutils literal"><span class="pre">diag.c</span></tt>.</li>
<li>Run the MPS and client in an environment that supports the channel
used (for example, at a command-line if using <a class="reference internal" href="writef.html#WriteF" title="WriteF"><tt class="xref c c-func docutils literal"><span class="pre">WriteF()</span></tt></a>).</li>
</ol>
<div class="section" id="what-is-a-diagnostic">
<h3>9.4.1. What is a diagnostic?<a class="headerlink" href="#what-is-a-diagnostic" title="Permalink to this headline"></a></h3>
<p>A diagnostic has three parts:</p>
<ol class="arabic simple">
<li>a trigger condition, that causes this diagnostic to be emitted;</li>
<li>a text tag (for example, &#8220;TraceStart&#8221;) which is the name of this
diagnostic; and</li>
<li>a paragraph of human-useful text.</li>
</ol>
<p>A diagnostic is emitted by the MPS at a certain point in time when a
certain event happens.</p>
<p>Diagnostics are not nested. Every diagnostic must have a tag. Each
diagnostic should have a unique tag (uniqueness is just to help the
humans; the diagnostic system does not care).</p>
<p>The paragraph of text can be many lines long. It usually explains what
event caused the diagnostic to be emitted, and commonly also includes
the output of some <tt class="xref c c-func docutils literal"><span class="pre">Describe()</span></tt> methods for various relevant
objects. (For example, the <tt class="docutils literal"><span class="pre">TraceStart</span></tt> diagnostic might call, and
include the output generated by, the <tt class="xref c c-func docutils literal"><span class="pre">TraceDescribe()</span></tt> method).</p>
</div>
<div class="section" id="how-do-i-control-filter-which-diagnostics-i-see">
<h3>9.4.2. How do I control (filter) which diagnostics I see?<a class="headerlink" href="#how-do-i-control-filter-which-diagnostics-i-see" title="Permalink to this headline"></a></h3>
<p>All diagnostics are emitted and then filtered according to the
&#8220;diagnostic filter rules&#8221;.</p>
<p>The first level of control is filtering by tag. (For example, only
show <tt class="docutils literal"><span class="pre">TraceStart</span></tt> diagnostics).</p>
<p>The second level of control is filtering by paragraph content. (For
example, only show <tt class="docutils literal"><span class="pre">TraceStart</span></tt> diagnostics where the trace is
started because a nursery generation is full).</p>
<p>The third level of control is filtering by line content. (For example,
only show lines containing the word <tt class="docutils literal"><span class="pre">whiteSet</span></tt>).</p>
<p>See <tt class="docutils literal"><span class="pre">diag.c</span></tt> for details.</p>
<p>Note: the entire filtering mechanism can be turned off, so that
diagnostics go immediately to <tt class="docutils literal"><span class="pre">mps_lib_get_stdout(0</span></tt>, with no
buffering or filtering See impl.c.diag.filter-disable.</p>
<p>To get diagnostic output from the MPS, you must use a variety with
diagnostics compiled-in. Currently, that means variety.cool. See
<tt class="docutils literal"><span class="pre">config.h</span></tt>.</p>
<p>There are two mechanism for getting diagnostic output:</p>
<ol class="arabic">
<li><p class="first">Automatically via the telemetry system. See design.mps.telemetry,
and the &#8220;Telemetry&#8221; chapter in the manual.</p>
</li>
<li><p class="first">Manually via the debugger. In the debugger, set break points at the
places where you want to inspect data structures (or wait for the
debugger to be entered via an <tt class="xref c c-func docutils literal"><span class="pre">abort()</span></tt> call or unhandled
segmentation fault). Then at the debugger command prompt, run
<tt class="xref c c-func docutils literal"><span class="pre">Describe()</span></tt> commands of your choice. For example:</p>
<div class="highlight-c"><pre>(gdb) run
Starting program: mv2test
Reading symbols for shared libraries +............................. done
cbs.c:94: MPS ASSERTION FAILED: !cbs-&gt;inCBS
Program received signal SIGABRT, Aborted.
0x00007fff83e42d46 in __kill ()
(gdb) frame 12
#12 0x000000010000b1fc in MVTFree (pool=0x103ffe160, base=0x101dfd000, size=5024) at poolmv2.c:711
711 Res res = CBSInsert(MVTCBS(mvt), base, limit);
(gdb) p MVTDescribe(mvt, mps_lib_get_stdout())
MVT 0000000103FFE160
{
minSize: 8
meanSize: 42
maxSize: 8192
fragLimit: 30
reuseSize: 16384
fillSize: 8192
availLimit: 1110835
abqOverflow: FALSE
splinter: TRUE
splinterSeg: 0000000103FEE780
splinterBase: 0000000101D7ABB8
splinterLimit: 0000000101D7B000
# ... etc ...
}</pre>
</div>
</li>
</ol>
</div>
<div class="section" id="how-to-write-a-diagnostic">
<h2>9.5. How to write a diagnostic<a class="headerlink" href="#how-to-write-a-diagnostic" title="Permalink to this headline"></a></h2>
<div class="section" id="improve-stateless-describe-methods-where-possible">
<h3>9.5.1. Improve stateless Describe methods where possible<a class="headerlink" href="#improve-stateless-describe-methods-where-possible" title="Permalink to this headline"></a></h3>
<p>Where possible, don&#8217;t put clever code into an event-triggered
diagnostic: put it into a stateless <tt class="xref c c-func docutils literal"><span class="pre">Describe()</span></tt> method instead, and
then call that method when emitting your diagnostic.</p>
<p>For example:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">FooDescribe</span><span class="p">(</span><span class="n">Foo</span> <span class="n">foo</span><span class="p">,</span> <span class="n">mps_lib_FILE</span> <span class="o">*</span><span class="n">stream</span><span class="p">)</span>
<span class="p">{</span>
<span class="cm">/* show value of new &quot;quux&quot; field */</span>
<span class="n">WriteF</span><span class="p">(</span><span class="n">stream</span><span class="p">,</span> <span class="s">&quot;Foo: $P { quux: $U }</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span> <span class="n">foo</span><span class="p">,</span> <span class="n">foo</span><span class="o">-&gt;</span><span class="n">quux</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">FooWibble</span><span class="p">(</span><span class="n">Foo</span> <span class="n">foo</span><span class="p">)</span>
<span class="p">{</span>
<span class="p">...</span>
<span class="n">DIAG_FIRSTF</span><span class="p">((</span> <span class="s">&quot;FooWibble&quot;</span><span class="p">,</span> <span class="s">&quot;Wibbling foo $P&quot;</span><span class="p">,</span> <span class="n">foo</span><span class="p">,</span> <span class="nb">NULL</span><span class="p">));</span>
<span class="n">DIAG</span><span class="p">(</span> <span class="n">FooDescribe</span><span class="p">(</span><span class="n">foo</span><span class="p">,</span> <span class="n">DIAG_STREAM</span><span class="p">);</span> <span class="p">);</span>
<span class="n">DIAG_END</span><span class="p">(</span><span class="s">&quot;FooWibble&quot;</span><span class="p">);</span>
<span class="p">...</span>
<span class="p">}</span>
</pre></div>
</div>
<p>This is much better, because other people can use your human-useful
output in their diagnostics, or &#8216;live&#8217; in a debugger.</p>
</div>
<div class="section" id="use-the-output-macros">
<h3>9.5.2. Use the output macros<a class="headerlink" href="#use-the-output-macros" title="Permalink to this headline"></a></h3>
<p>For a simple diagnostic, use <tt class="xref c c-func docutils literal"><span class="pre">DIAG_SINGLEF()</span></tt>. This begins the tag,
puts text into the paragraph, and ends the tag immediately.</p>
<p>For a more complex diagnostic, the first call must be
<tt class="xref c c-func docutils literal"><span class="pre">DIAG_FIRSTF()</span></tt>, which begins a diag tag.</p>
<p>While a tag is current, you can add text to the diagnostic&#8217;s paragraph
using <tt class="xref c c-func docutils literal"><span class="pre">DIAG_MOREF()</span></tt>, and <tt class="docutils literal"><span class="pre">WriteF(</span> <span class="pre">DIAG_STREAM,</span> <span class="pre">...</span> <span class="pre">)</span></tt>.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last"><tt class="xref c c-macro docutils literal"><span class="pre">DIAG_STREAM</span></tt> is not a real standard C library stream. If you
want stream-level access, you may use <tt class="xref c c-func docutils literal"><span class="pre">Stream_fputc()</span></tt> and
<tt class="xref c c-func docutils literal"><span class="pre">Stream_fputs()</span></tt>.</p>
</div>
<p>End the tag by calling <tt class="xref c c-macro docutils literal"><span class="pre">DIAG_END</span></tt>.</p>
</div>
<div class="section" id="compile-away-in-non-diag-varieties-no-side-effects">
<h3>9.5.3. Compile away in non-diag varieties; no side effects<a class="headerlink" href="#compile-away-in-non-diag-varieties-no-side-effects" title="Permalink to this headline"></a></h3>
<p>Wrap non-output code with the <tt class="xref c c-func docutils literal"><span class="pre">DIAG()</span></tt> and <tt class="xref c c-func docutils literal"><span class="pre">DIAG_DECL()</span></tt> macros,
to make sure that non-diag varieties do not execute
diagnostic-generating code.</p>
<p>For complex diagnostic-generating code, it may be cleaner to move it
into a separate local function. Put <tt class="docutils literal"><span class="pre">_diag</span></tt> on the end of the function
name (for example, <tt class="xref c c-func docutils literal"><span class="pre">TraceStart_diag()</span></tt>).</p>
<p>Obviously, diagnostic-generating code must have no side effects.</p>
</div>
<div class="section" id="choosing-tags">
<h3>9.5.4. Choosing tags<a class="headerlink" href="#choosing-tags" title="Permalink to this headline"></a></h3>
<p>Tags should be valid C identifiers. Unless you know of a good reason
why not. (Not currently checked).</p>
<p>There&#8217;s no formal scheme for tag naming, but make it helpful and
informally hierarchical, for example, <tt class="docutils literal"><span class="pre">TraceBegin</span></tt>, <tt class="docutils literal"><span class="pre">TraceStart</span></tt>,
<tt class="docutils literal"><span class="pre">TraceEnd</span></tt>, and so on, not <tt class="docutils literal"><span class="pre">BeginTrace</span></tt>, <tt class="docutils literal"><span class="pre">EndTrace</span></tt>.</p>
<h3>9.5.1. Compile away in non-diag varieties; no side effects<a class="headerlink" href="#compile-away-in-non-diag-varieties-no-side-effects" title="Permalink to this headline"></a></h3>
<p>Wrap code with the <tt class="xref c c-macro docutils literal"><span class="pre">STATISTIC</span></tt> and <tt class="xref c c-macro docutils literal"><span class="pre">METER</span></tt> macros, to make sure
that non-diagnostic varieties do not execute diagnostic-generating
code.</p>
<p>Diagnostic-generating code must have no side effects.</p>
</div>
<div class="section" id="writing-good-paragraph-text">
<h3>9.5.5. Writing good paragraph text<a class="headerlink" href="#writing-good-paragraph-text" title="Permalink to this headline"></a></h3>
<p>IMPORTANT: Make your diagnostics easy to understand! Other people will
read your diagnostics! Make them clear and helpful. Do not make them
terse and cryptic. If you use symbols, print a key in the diagnostic.
(If you don&#8217;t want to see this the screen clutter, then you can always
add a filter rule to your personal rule set to filter it out).</p>
</div>
<div class="section" id="maintaining-helpful-filter-rules">
<h3>9.5.6. Maintaining helpful filter rules<a class="headerlink" href="#maintaining-helpful-filter-rules" title="Permalink to this headline"></a></h3>
<p>If you add a noisy diagnostic, add a rule to the default ruleset to
turn it off.</p>
<h3>9.5.2. Writing good paragraph text<a class="headerlink" href="#writing-good-paragraph-text" title="Permalink to this headline"></a></h3>
<p>Make your diagnostics easy to understand! Other people will read your
diagnostics! Make them clear and helpful. Do not make them terse and
cryptic. If you use symbols, print a key in the diagnostic.</p>
</div>
</div>
<div class="section" id="how-the-mps-diagnostic-system-works">
<h2>9.6. How the MPS diagnostic system works<a class="headerlink" href="#how-the-mps-diagnostic-system-works" title="Permalink to this headline"></a></h2>
<div class="section" id="channels">
<h3>9.6.1. Channels<a class="headerlink" href="#channels" title="Permalink to this headline"></a></h3>
<p>The recommended channel is <a class="reference internal" href="writef.html#WriteF" title="WriteF"><tt class="xref c c-func docutils literal"><span class="pre">WriteF()</span></tt></a> to standard output.</p>
<p>Other possible of future channels might be:</p>
<ul class="simple">
<li><tt class="xref c c-func docutils literal"><span class="pre">printf()</span></tt>;</li>
<li>a new type (yet to be defined) of <tt class="docutils literal"><span class="pre">mps_message</span></tt>;</li>
<li>squirt them into the telemetry-log-events system;</li>
<li>telnet.</li>
</ul>
<p>Currently, only <tt class="xref c c-func docutils literal"><span class="pre">printf()</span></tt> and <a class="reference internal" href="writef.html#WriteF" title="WriteF"><tt class="xref c c-func docutils literal"><span class="pre">WriteF()</span></tt></a> are supported. See the
<tt class="xref c c-macro docutils literal"><span class="pre">DIAG_WITH_</span></tt> macros in <tt class="docutils literal"><span class="pre">mpm.h</span></tt>.</p>
<p>You can also use a debugger to call <tt class="xref c c-func docutils literal"><span class="pre">Describe()</span></tt> methods directly,
from within the debugger.</p>
<p>Note: it is unfortunate that choice of channel may (for some channels)
also dictate the form of the code that synthesises the message. (For
example, <a class="reference internal" href="writef.html#WriteF" title="WriteF"><tt class="xref c c-func docutils literal"><span class="pre">WriteF()</span></tt></a> style parameter-expansion is not possible when
using the <tt class="xref c c-func docutils literal"><span class="pre">printf()</span></tt> channel, because there is no way to get
<a class="reference internal" href="writef.html#WriteF" title="WriteF"><tt class="xref c c-func docutils literal"><span class="pre">WriteF()</span></tt></a> to produce its output into a string). This is just a
technical hitch; logically, the code that synthesises a diagnostic
message should not care which channel will be used to transmit it out
of the MPS.</p>
</div>
<div class="section" id="parts-of-the-mps-diagnostic-system">
<h3>9.6.2. Parts of the MPS diagnostic system<a class="headerlink" href="#parts-of-the-mps-diagnostic-system" title="Permalink to this headline"></a></h3>
<h3>9.6.1. Parts of the MPS diagnostic system<a class="headerlink" href="#parts-of-the-mps-diagnostic-system" title="Permalink to this headline"></a></h3>
<p><span class="target" id="design.mps.diag.parts"></span><a class="mpstag reference internal" href="#design.mps.diag.parts">.parts:</a> The following facilities are considered part of the MPS
diagnostic system:</p>
<ul class="simple">
<li>the <tt class="xref c c-func docutils literal"><span class="pre">Describe()</span></tt> methods.</li>
<li>the <tt class="xref c c-macro docutils literal"><span class="pre">DIAG</span></tt> macros (<tt class="xref c c-macro docutils literal"><span class="pre">DIAG</span></tt>, <tt class="xref c c-macro docutils literal"><span class="pre">DIAG_DECL</span></tt>, <tt class="docutils literal"><span class="pre">DIAG_*F</span></tt>, and so on);</li>
<li>the <tt class="xref c c-macro docutils literal"><span class="pre">STATISTIC</span></tt> macros (see <tt class="docutils literal"><span class="pre">mpm.h</span></tt>);</li>
<li>the <tt class="xref c c-macro docutils literal"><span class="pre">METER</span></tt> macros and meter subsystem.</li>
</ul>
</div>
<div class="section" id="related-systems">
<h3>9.6.3. Related systems<a class="headerlink" href="#related-systems" title="Permalink to this headline"></a></h3>
<h3>9.6.2. Related systems<a class="headerlink" href="#related-systems" title="Permalink to this headline"></a></h3>
<p>The MPS diagnostic system is separate from the following other MPS
systems:</p>
<ul class="simple">
@ -305,24 +212,15 @@ <h3><a href="../index.html">Table Of Contents</a></h3>
<li><a class="reference internal" href="#introduction">9.1. Introduction</a></li>
<li><a class="reference internal" href="#overview">9.2. Overview</a></li>
<li><a class="reference internal" href="#requirements">9.3. Requirements</a></li>
<li><a class="reference internal" href="#usage">9.4. Usage</a><ul>
<li><a class="reference internal" href="#what-is-a-diagnostic">9.4.1. What is a diagnostic?</a></li>
<li><a class="reference internal" href="#how-do-i-control-filter-which-diagnostics-i-see">9.4.2. How do I control (filter) which diagnostics I see?</a></li>
</ul>
</li>
<li><a class="reference internal" href="#usage">9.4. Usage</a></li>
<li><a class="reference internal" href="#how-to-write-a-diagnostic">9.5. How to write a diagnostic</a><ul>
<li><a class="reference internal" href="#improve-stateless-describe-methods-where-possible">9.5.1. Improve stateless Describe methods where possible</a></li>
<li><a class="reference internal" href="#use-the-output-macros">9.5.2. Use the output macros</a></li>
<li><a class="reference internal" href="#compile-away-in-non-diag-varieties-no-side-effects">9.5.3. Compile away in non-diag varieties; no side effects</a></li>
<li><a class="reference internal" href="#choosing-tags">9.5.4. Choosing tags</a></li>
<li><a class="reference internal" href="#writing-good-paragraph-text">9.5.5. Writing good paragraph text</a></li>
<li><a class="reference internal" href="#maintaining-helpful-filter-rules">9.5.6. Maintaining helpful filter rules</a></li>
<li><a class="reference internal" href="#compile-away-in-non-diag-varieties-no-side-effects">9.5.1. Compile away in non-diag varieties; no side effects</a></li>
<li><a class="reference internal" href="#writing-good-paragraph-text">9.5.2. Writing good paragraph text</a></li>
</ul>
</li>
<li><a class="reference internal" href="#how-the-mps-diagnostic-system-works">9.6. How the MPS diagnostic system works</a><ul>
<li><a class="reference internal" href="#channels">9.6.1. Channels</a></li>
<li><a class="reference internal" href="#parts-of-the-mps-diagnostic-system">9.6.2. Parts of the MPS diagnostic system</a></li>
<li><a class="reference internal" href="#related-systems">9.6.3. Related systems</a></li>
<li><a class="reference internal" href="#parts-of-the-mps-diagnostic-system">9.6.1. Parts of the MPS diagnostic system</a></li>
<li><a class="reference internal" href="#related-systems">9.6.2. Related systems</a></li>
</ul>
</li>
<li><a class="reference internal" href="#references">9.7. References</a></li>

10
mps/manual/html/design/message-gc.html
View file

@ -108,9 +108,10 @@ <h2>18.4. Purpose<a class="headerlink" href="#purpose" title="Permalink to this
be extra content that is only meaningful to MPS staff, to help us
diagnose client problems.</p>
<p>While there is some overlap with the Diagnostic Feedback system
(design.mps.diag), the main contrasts are that these GC messages are
present in release builds, are stable from release to release, and are
designed to be parsed by the client program.</p>
(design.mps.diag) and the Telemetry system (design.mps.telemetry), the
main contrasts are that these GC messages are present in release
builds, are stable from release to release, and are designed to be
parsed by the client program.</p>
</div>
<div class="section" id="names-and-parts">
<h2>18.5. Names and parts<a class="headerlink" href="#names-and-parts" title="Permalink to this headline"></a></h2>
@ -252,8 +253,7 @@ <h3>18.6.3. Creating and Posting<a class="headerlink" href="#creating-and-postin
end message will be sent (<a class="reference internal" href="#design.mps.config.req.match">.req.match</a>). There is no direct way to
report this failure to the client (<a class="reference internal" href="#design.mps.config.req.errors-not-direct">.req.errors-not-direct</a>), so we
just increment the <tt class="docutils literal"><span class="pre">droppedMessages</span></tt> counter in the <tt class="xref c c-type docutils literal"><span class="pre">ArenaStruct</span></tt>.
Currently this counter is never reported to the client (except in
diagnostic varieties).</p>
This counter is available via the <tt class="docutils literal"><span class="pre">MessagesDropped</span></tt> telemetry event.</p>
</div>
<div class="section" id="getting-and-discarding">
<h3>18.6.4. Getting and discarding<a class="headerlink" href="#getting-and-discarding" title="Permalink to this headline"></a></h3>

20
mps/manual/html/design/old.html
View file

@ -156,6 +156,7 @@ <h3>Navigation</h3>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="bt.html#testing">4.10. Testing</a></li>
<li class="toctree-l2"><a class="reference internal" href="bt.html#references">4.11. References</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="buffer.html">5. Allocation buffers and allocation points</a><ul>
@ -211,24 +212,15 @@ <h3>Navigation</h3>
<li class="toctree-l2"><a class="reference internal" href="diag.html#introduction">9.1. Introduction</a></li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#overview">9.2. Overview</a></li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#requirements">9.3. Requirements</a></li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#usage">9.4. Usage</a><ul>
<li class="toctree-l3"><a class="reference internal" href="diag.html#what-is-a-diagnostic">9.4.1. What is a diagnostic?</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#how-do-i-control-filter-which-diagnostics-i-see">9.4.2. How do I control (filter) which diagnostics I see?</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#usage">9.4. Usage</a></li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#how-to-write-a-diagnostic">9.5. How to write a diagnostic</a><ul>
<li class="toctree-l3"><a class="reference internal" href="diag.html#improve-stateless-describe-methods-where-possible">9.5.1. Improve stateless Describe methods where possible</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#use-the-output-macros">9.5.2. Use the output macros</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#compile-away-in-non-diag-varieties-no-side-effects">9.5.3. Compile away in non-diag varieties; no side effects</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#choosing-tags">9.5.4. Choosing tags</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#writing-good-paragraph-text">9.5.5. Writing good paragraph text</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#maintaining-helpful-filter-rules">9.5.6. Maintaining helpful filter rules</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#compile-away-in-non-diag-varieties-no-side-effects">9.5.1. Compile away in non-diag varieties; no side effects</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#writing-good-paragraph-text">9.5.2. Writing good paragraph text</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#how-the-mps-diagnostic-system-works">9.6. How the MPS diagnostic system works</a><ul>
<li class="toctree-l3"><a class="reference internal" href="diag.html#channels">9.6.1. Channels</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#parts-of-the-mps-diagnostic-system">9.6.2. Parts of the MPS diagnostic system</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#related-systems">9.6.3. Related systems</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#parts-of-the-mps-diagnostic-system">9.6.1. Parts of the MPS diagnostic system</a></li>
<li class="toctree-l3"><a class="reference internal" href="diag.html#related-systems">9.6.2. Related systems</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="diag.html#references">9.7. References</a></li>

15
mps/manual/html/design/poolamc.html
View file

@ -289,13 +289,12 @@ <h3>21.2.7. Retained pages<a class="headerlink" href="#retained-pages" title="Pe
<h3>21.2.8. Feedback about retained pages<a class="headerlink" href="#feedback-about-retained-pages" title="Permalink to this headline"></a></h3>
<p>(New with <a class="reference external" href="http://www.ravenbrook.com/project/mps/issue/job001811/">job001811</a>). AMC now accumulates counts of pages condemned
and retained during a trace, in categories according to size and
reason for retention, and emits diagnostic at trace-end via the
<tt class="docutils literal"><span class="pre">pool-&gt;class-&gt;traceEnd</span></tt> method. See comments on the
<tt class="xref c c-type docutils literal"><span class="pre">PageRetStruct</span></tt> in poolamc.c. These page-based metrics are not as
precise as actually counting the size of objects, but they require
much less intrusive code to implement, and should be sufficient to
assess whether AMC&#8217;s page retention policies and behaviour are
acceptable.</p>
reason for retention, and emits this via the <tt class="docutils literal"><span class="pre">AMCTraceEnd</span></tt> telemetry
event. See comments on the <tt class="xref c c-type docutils literal"><span class="pre">PageRetStruct</span></tt> in <tt class="docutils literal"><span class="pre">poolamc.c</span></tt>. These
page-based metrics are not as precise as actually counting the size of
objects, but they require much less intrusive code to implement, and
should be sufficient to assess whether AMC&#8217;s page retention policies
and behaviour are acceptable.</p>
</div>
</div>
<div class="section" id="initial-design">
@ -528,7 +527,7 @@ <h3>21.3.9. Generations<a class="headerlink" href="#generations" title="Permalin
<h3>21.3.10. Ramps<a class="headerlink" href="#ramps" title="Permalink to this headline"></a></h3>
<p><span class="target" id="design.mps.poolamc.ramp"></span><a class="mpstag reference internal" href="#design.mps.poolamc.ramp">.ramp:</a> Ramps usefully implement the begin/end
<a class="reference internal" href="../topic/pattern.html#mps_alloc_pattern_ramp" title="mps_alloc_pattern_ramp"><tt class="xref c c-func docutils literal"><span class="pre">mps_alloc_pattern_ramp()</span></tt></a> interface.</p>
<p><span class="target" id="design.mps.poolamc.gen.ramp"></span><a class="mpstag reference internal" href="#design.mps.poolamc.gen.ramp">.gen.ramp:</a> To implement ramping (request.dylan.170423), AMC uses a
<p><span class="target" id="design.mps.poolamc.gen.ramp"></span><a class="mpstag reference internal" href="#design.mps.poolamc.gen.ramp">.gen.ramp:</a> To implement ramping (<a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170423">request.dylan.170423</a>), AMC uses a
special &#8220;ramping mode&#8221;, where promotions are redirected. One
generation is designated the &#8220;ramp generation&#8221; (<tt class="docutils literal"><span class="pre">amc-&gt;rampGen</span></tt> in
the code).</p>

2
mps/manual/html/design/poolawl.html
View file

@ -69,7 +69,7 @@ <h2>23.2. Requirements<a class="headerlink" href="#requirements" title="Permalin
<p>See req.dylan.fun.weak.</p>
<p>See meeting.dylan.1997-02-27(0) where many of the requirements for
this pool were first sorted out.</p>
<p>Must satisfy request.dylan.170123.</p>
<p>Must satisfy <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170123">request.dylan.170123</a>.</p>
<p><span class="target" id="design.mps.poolawl.req.obj-format"></span><a class="mpstag reference internal" href="#design.mps.poolawl.req.obj-format">.req.obj-format:</a> Only objects of a certain format need be
supported. This format is a subset of the Dylan Object Format. The
pool uses the first slot in the fixed part of an object to store an

2
mps/manual/html/design/poolmvff.html
View file

@ -170,7 +170,7 @@ <h2>27.6. Details<a class="headerlink" href="#details" title="Permalink to this
object size (in both cases we align up).</p>
<p><span class="target" id="design.mps.poolmvff.design.seg-fail"></span><a class="mpstag reference internal" href="#design.mps.poolmvff.design.seg-fail">.design.seg-fail:</a> If allocating a segment fails, we try again with
a segment size just large enough for the object we&#8217;re allocating. This
is in response to <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/mps/170186/">request.mps.170186</a>.</p>
is in response to <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/mps/170186">request.mps.170186</a>.</p>
</div>
</div>

464
mps/manual/html/design/strategy.html Normal file
View file

@ -0,0 +1,464 @@
<!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>MPS Strategy &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" />
</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><a href="../index.html">Memory Pool System 1.111.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="mps-strategy">
<span id="design-strategy"></span><h1>MPS Strategy<a class="headerlink" href="#mps-strategy" title="Permalink to this headline"></a></h1>
<div class="section" id="introduction">
<span id="design.mps.strategy"></span><h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline"></a></h2>
<p><span class="target" id="intro">.intro</span> This is the design of collection strategy for the MPS.</p>
<p><span class="target" id="readership">.readership</span> MPS developers.</p>
</div>
<div class="section" id="overview">
<h2>Overview<a class="headerlink" href="#overview" title="Permalink to this headline"></a></h2>
<p><span class="target" id="id1">.overview</span> The MPS uses &#8220;strategy&#8221; code to make three decisions:</p>
<ul class="simple">
<li>when to start a collection trace;</li>
<li>what to condemn;</li>
<li>how to schedule tracing work.</li>
</ul>
<p>This document describes the current strategy, identifies some
weaknesses in it, and outlines some possible future development
directions.</p>
</div>
<div class="section" id="requirements">
<h2>Requirements<a class="headerlink" href="#requirements" title="Permalink to this headline"></a></h2>
<p>[TODO: source some from req.dylan, or do an up-to-date requirements
analysis &#8211; NB 2013-03-25]</p>
<p>Garbage collection is a trade-off between time and space: it consumes
some [CPU] time in order to save some [memory] space. Strategy shifts
the balance point. A better strategy will take less time to produce
more space. Examples of good strategy might include:</p>
<ul class="simple">
<li>choosing segments to condemn which contain high proportions of dead
objects;</li>
<li>starting a trace when a large number of objects have just died;</li>
<li>doing enough collection soon enough that the client program never
suffers low-memory problems;</li>
<li>using otherwise-idle CPU resources for tracing.</li>
</ul>
<p>Conversely, it would be bad strategy to do the reverse of each of
these (condemning live objects; tracing when there&#8217;s very little
garbage; not collecting enough; tracing when the client program is
busy).</p>
<p>Abstracting from these notions, requirements on strategy would
relate to:</p>
<ul class="simple">
<li>Maximum pause time and other utilization metrics (for example,
bounded mutator utilization, minimum mutator utilization, total MPS
CPU usage);</li>
<li>Collecting enough garbage (for example: overall heap size;
low-memory requirements).</li>
<li>Allowing client control (for example, client recommendations for
collection timing or condemnation).</li>
</ul>
<p>There are other possible strategy considerations which are so far
outside the scope of current strategy and MPS design that this
document disregards them. For example, either inferring or allowing
the client to specify preferred relative object locations (&#8220;this
object should be kept in the same cache line as that one&#8221;), to improve
cache locality.</p>
</div>
<div class="section" id="generations">
<h2>Generations<a class="headerlink" href="#generations" title="Permalink to this headline"></a></h2>
<p>The largest part of the current MPS strategy implementation is the
support for generational GC. Generations are only fully supported for
AMC (and AMCZ) pools. See under &#8220;Non-AMC Pools&#8221;, below, for more
information.</p>
<div class="section" id="data-structures">
<h3>Data Structures<a class="headerlink" href="#data-structures" title="Permalink to this headline"></a></h3>
<p>The fundamental structure of generational GC is the <tt class="docutils literal"><span class="pre">Chain</span></tt>,
which describes a set of generations. A chain is created by client
code calling <a class="reference internal" href="../topic/collection.html#mps_chain_create" title="mps_chain_create"><tt class="xref c c-func docutils literal"><span class="pre">mps_chain_create()</span></tt></a>, specifying the &#8220;size&#8221; and
&#8220;mortality&#8221; for each generation. When creating an AMC pool, the
client code must specify the chain which will control collections for
that pool. The same chain may be used for multiple pools.</p>
<p>Each generation in a chain has a <tt class="docutils literal"><span class="pre">GenDesc</span></tt> structure,
allocated in an array pointed to from the chain. Each AMC pool has a
set of <tt class="docutils literal"><span class="pre">PoolGen</span></tt> structures, one per generation. The PoolGens
for each generation point to the GenDesc and are linked together in a
ring on the GenDesc. These structures are (solely?) used to gather
information for strategy decisions.</p>
<p>The arena has a unique <tt class="docutils literal"><span class="pre">GenDesc</span></tt> structure, named
<tt class="docutils literal"><span class="pre">topGen</span></tt> and described in comments as &#8220;the dynamic generation&#8221;
(although in fact it is the <em>least</em> dynamic generation). Each AMC
pool has one more PoolGen than there are GenDescs in the chain. The
extra PoolGen refers to this topGen.</p>
<p>AMC segments have a segment descriptor <tt class="docutils literal"><span class="pre">amcSegStruct</span></tt> which is
a <tt class="xref c c-type docutils literal"><span class="pre">GCSegStruct</span></tt> with two additional fields. One field
<tt class="docutils literal"><span class="pre">segTypeP</span></tt> is a pointer either to the per-generation per-pool
<tt class="docutils literal"><span class="pre">amcGen</span></tt> structure (a subclass of <tt class="docutils literal"><span class="pre">PoolGen</span></tt>), or to a
nailboard (which then points to an amcGen). The other field
<tt class="docutils literal"><span class="pre">new</span></tt> is a boolean used for keeping track of memory usage for
strategy reasons (see below under &#8216;Accounting&#8217;). The <tt class="docutils literal"><span class="pre">amcGen</span></tt>
is used for statistics (<tt class="docutils literal"><span class="pre">-&gt;segs</span></tt>) and forwarding buffers
(<tt class="docutils literal"><span class="pre">-&gt;forward</span></tt>).</p>
<p>The AMC pool class only ever allocates a segment in order to fill a
buffer: either the buffer for a client Allocation Point, or a
forwarding buffer. In order to support generational collection, there
is a subclass <tt class="docutils literal"><span class="pre">amcBuf</span></tt> of <tt class="docutils literal"><span class="pre">SegBuf</span></tt>, with a
<tt class="docutils literal"><span class="pre">gen</span></tt> field (pointing to a <tt class="docutils literal"><span class="pre">amcGen</span></tt>). So in
<a class="reference internal" href="poolamc.html#AMCBufferFill" title="AMCBufferFill"><tt class="xref c c-func docutils literal"><span class="pre">AMCBufferFill()</span></tt></a> the generation of the new segment can be
determined.</p>
<p>When an AMC pool is created, these <tt class="docutils literal"><span class="pre">amcGen</span></tt> and
<tt class="docutils literal"><span class="pre">amcBuf</span></tt> structures are all created, and the
<tt class="docutils literal"><span class="pre">amcBuf-&gt;gen</span></tt> fields initialized so that the forwarding buffer
of each amcGen knows that it belongs to the next &#8220;older&#8221; amcGen (apart
from the &#8220;oldest&#8221; amcGen - that which refers to the topGen - whose
forwarding buffer belongs to itself).</p>
<p>When copying an object in <a class="reference internal" href="poolamc.html#AMCFix" title="AMCFix"><tt class="xref c c-func docutils literal"><span class="pre">AMCFix()</span></tt></a>, the object&#8217;s current
generation is determined (<tt class="xref c c-func docutils literal"><span class="pre">amcSegGen()</span></tt>), and the object is
copied to that amcGen&#8217;s forwarding buffer, using the buffer protocol.
Thus, objects are &#8220;promoted&#8221; up the chain of generations until they
end up in the topGen, which is shared between all chains and all
pools.</p>
<p>For statistics and reporting purposes, when <tt class="xref c c-macro docutils literal"><span class="pre">STATISTICS</span></tt> is
on, each AMC pool has an array of <tt class="xref c c-type docutils literal"><span class="pre">PageRetStruct`s,</span> <span class="pre">one</span> <span class="pre">per</span>
<span class="pre">trace.</span>&nbsp; <span class="pre">This</span> <span class="pre">structure</span> <span class="pre">has</span> <span class="pre">many</span> <span class="pre">:c:type:`Count</span></tt> fields, and is
intended to help to assess AMC page retention code. See job001811.</p>
</div>
<div class="section" id="zones">
<h3>Zones<a class="headerlink" href="#zones" title="Permalink to this headline"></a></h3>
<p>All collections in the MPS start with condemnation of a complete
<tt class="docutils literal"><span class="pre">ZoneSet</span></tt>. Each generation in each chain has a zoneset
associated with it (<tt class="docutils literal"><span class="pre">chain-&gt;gen[N].zones</span></tt>); the condemned
zoneset is the union of some number of generation&#8217;s zonesets. It is
condemned by code in the chain system calling
<tt class="xref c c-func docutils literal"><span class="pre">TraceCondemnZones()</span></tt>. This is either for all chains
(<tt class="xref c c-func docutils literal"><span class="pre">ChainCondemnAll()</span></tt> called for every chain from
<tt class="xref c c-func docutils literal"><span class="pre">traceCondemnAll()</span></tt>) or for some number of generations in a
single chain (<tt class="xref c c-func docutils literal"><span class="pre">ChainCondemnAuto()</span></tt> called from
<tt class="xref c c-func docutils literal"><span class="pre">TracePoll()</span></tt>). Note that the condemnation is of every
automatic-pool segment in any zone in the zoneset. It is not limited
to the segments actually associated with the condemned generation(s).</p>
<p>An attempt is made to use distinct zonesets for different generations.
Whenever a segment is allocated (<a class="reference internal" href="poolamc.html#AMCBufferFill" title="AMCBufferFill"><tt class="xref c c-func docutils literal"><span class="pre">AMCBufferFill()</span></tt></a>), a
<tt class="docutils literal"><span class="pre">SegPref</span></tt> is created containing the generation number
(obtained from <tt class="docutils literal"><span class="pre">amcBuf-&gt;gen-&gt;pgen-&gt;nr</span></tt>) and passed to
<tt class="xref c c-func docutils literal"><span class="pre">SegAlloc()</span></tt>. The arena keeps a zoneset for each generation
number (up to <tt class="docutils literal"><span class="pre">VMArenaGenCount</span></tt>, defined in
<tt class="docutils literal"><span class="pre">arenavm.c</span></tt> to be <tt class="docutils literal"><span class="pre">MPS_WORD_WIDTH/2</span></tt>), and a
<tt class="docutils literal"><span class="pre">freeSet</span></tt>. The zoneset for each generation number starts out
empty, and the <tt class="docutils literal"><span class="pre">freeSet</span></tt> starts out <tt class="docutils literal"><span class="pre">ZoneSetUNIV</span></tt>.
When a segment is allocated with a <tt class="docutils literal"><span class="pre">SegPref</span></tt> with a generation
number, an attempt is made to allocate it in the corresponding zoneset
(<tt class="xref c c-func docutils literal"><span class="pre">pagesFindFreeInZones()</span></tt>). If the zoneset is empty, an
attempt is made to allocate it in the <tt class="docutils literal"><span class="pre">freeSet</span></tt> zoneset.
After it is allocated, the zones it occupies are removed from the
<tt class="docutils literal"><span class="pre">freeSet</span></tt> and (if there&#8217;s a generation <tt class="docutils literal"><span class="pre">SegPref</span></tt>)
added to the zoneset for that generation number.</p>
<p>Note that this zone placement code knows nothing of chains,
generations, pool classes, etc. It is based solely on the generation
<em>number</em>, so generations with the same number from different chains
share a zoneset preference for the purpose of placing newly allocated
segments. Combined with the fact that condemnation is per-zone, this
effectively means that generations in distinct chains are collected
together. One consequence of this is that we don&#8217;t have a very fine
granularity of control over collection: a garbage collection of all
chains together is triggered by the most eager chain. There&#8217;s no way
for a library or other small part of a client program to arrange
independent collection of a separate pool or chain.</p>
<p>When <a class="reference internal" href="poolamc.html#AMCBufferFill" title="AMCBufferFill"><tt class="xref c c-func docutils literal"><span class="pre">AMCBufferFill()</span></tt></a> gets the allocated segment back, it
adds it to the zoneset associated with that generation in the pool&#8217;s
controlling chain. Note that a chain&#8217;s per-generation zonesets, which
represent the zones in which segments for that generation in that
chain have been placed, are quite distinct from the arena-wide
per-generation-number zonesets, which represent the zones in which
segments for that generation number in any chain have been placed.
The arena-wide per-generation-number zoneset
<tt class="docutils literal"><span class="pre">vmArena-&gt;genZoneSet[N]</span></tt> is augmented in
<tt class="xref c c-func docutils literal"><span class="pre">vmAllocComm()</span></tt>. The per-chain per-generation zoneset
<tt class="docutils literal"><span class="pre">chain-&gt;gen[N].zones</span></tt> is augmented in
<tt class="xref c c-func docutils literal"><span class="pre">PoolGenUpdateZones()</span></tt>. Neither kind of zoneset can ever
shrink.</p>
</div>
<div class="section" id="accounting">
<h3>Accounting<a class="headerlink" href="#accounting" title="Permalink to this headline"></a></h3>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">gen[N].mortality</span></tt><ul>
<li>Specified by the client.</li>
<li>TODO: fill in how this is used.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">gen[N].capacity</span></tt><ul>
<li>Specified by the client.</li>
<li>TODO: fill in how this is used.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">amcSeg-&gt;new</span></tt><ul>
<li>TODO: fill this in</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">pgen-&gt;totalSize</span></tt>:<ul>
<li>incremented by <a class="reference internal" href="poolamc.html#AMCBufferFill" title="AMCBufferFill"><tt class="xref c c-func docutils literal"><span class="pre">AMCBufferFill()</span></tt></a>;</li>
<li>decremented by <tt class="xref c c-func docutils literal"><span class="pre">amcReclaimNailed()</span></tt> and <a class="reference internal" href="poolamc.html#AMCReclaim" title="AMCReclaim"><tt class="xref c c-func docutils literal"><span class="pre">AMCReclaim()</span></tt></a>;</li>
<li>added up by <tt class="docutils literal"><span class="pre">GenDescTotalSize(gen)</span></tt>.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">pgen-&gt;newSize</span></tt>:<ul>
<li>incremented by <a class="reference internal" href="poolamc.html#AMCBufferFill" title="AMCBufferFill"><tt class="xref c c-func docutils literal"><span class="pre">AMCBufferFill()</span></tt></a> (<em>when not ramping</em>) and <tt class="xref c c-func docutils literal"><span class="pre">AMCRampEnd()</span></tt>;</li>
<li>decremented by <tt class="xref c c-func docutils literal"><span class="pre">AMCWhiten()</span></tt>,</li>
<li>added up by <tt class="docutils literal"><span class="pre">GenDescNewSize(gen)</span></tt>.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">gen[N].proflow</span></tt>:<ul>
<li>set to 1.0 by <tt class="xref c c-func docutils literal"><span class="pre">ChainCreate()</span></tt>;</li>
<li><tt class="docutils literal"><span class="pre">arena-&gt;topGen.proflow</span></tt> set to 0.0 by <tt class="docutils literal"><span class="pre">LocusInit(arena)</span></tt>;</li>
<li><em>The value of this field is never used</em>.</li>
</ul>
</li>
<li><tt class="docutils literal"><span class="pre">pgen-&gt;newSizeAtCreate</span></tt>:<ul>
<li>set by <tt class="xref c c-func docutils literal"><span class="pre">traceCopySizes()</span></tt> (that is its purpose);</li>
<li>output in the <tt class="docutils literal"><span class="pre">TraceStartPoolGen</span></tt> telemetry event.</li>
</ul>
</li>
</ul>
</div>
<div class="section" id="ramps">
<h3>Ramps<a class="headerlink" href="#ramps" title="Permalink to this headline"></a></h3>
<p>The intended semantics of ramping are pretty simple. It allows the
client to advise us of periods of large short-lived allocation on a
particular AP. Stuff allocated using that AP during its &#8220;ramp&#8221; will
probably be dead when the ramp finishes. How the MPS makes use of this
advice is up to us, but for instance we might segregate those objects,
collect them less enthusiastically during the ramp and then more
enthusiastically soon after the ramp finishes. Ramps can nest.</p>
<p>A ramp is entered by calling:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">mps_ap_alloc_pattern_begin</span><span class="p">(</span><span class="n">ap</span><span class="p">,</span> <span class="n">mps_alloc_pattern_ramp</span><span class="p">())</span>
</pre></div>
</div>
<p>or similar, and left in a similar way.</p>
<p>This is implemented on a per-pool basis, for AMC only (it&#8217;s ignored by
the other automatic pools). PoolAMC throws away the identity of the AP
specified by the client. The implementation is intended to work by
changing the generational forwarding behaviour, so that there is a &#8220;ramp
generation&#8221; - one of the regular AMC generations - which forwards to
itself if collected during a ramp (instead of promoting to an older
generation). It also tweaks the strategy calculation code, in a way
with consequences I am documenting elsewhere.</p>
<p>Right now, the code sets this ramp generation to the last generation
specified in the pool&#8217;s &#8220;chain&#8221;: it ordinarily forwards to the
&#8220;after-ramp&#8221; generation, which is the &#8220;dynamic generation&#8221; (i.e. the
least dynamic generation, i.e. the arena-wide &#8220;top generation&#8221;). My
recollection, and some mentions in design/poolamc, suggests that the
ramp generation used to be chosen differently from this.</p>
<p>So far, it doesn&#8217;t sound too ghastly, I guess, although the subversion
of the generational system seems a little daft. Read on....</p>
<p>An AMC pool has a <tt class="docutils literal"><span class="pre">rampMode</span></tt> (which is really a state of a state
machine), taking one of five values: OUTSIDE, BEGIN, RAMPING, FINISH,
and COLLECTING (actually the enum values are called RampX for these
X). We initialize in OUTSIDE. The pool also has a <tt class="docutils literal"><span class="pre">rampCount</span></tt>,
which is the ramp nesting depth and is used to allow us to ignore ramp
transitions other than the outermost. According to design/poolamc,
there&#8217;s an invariant (in BEGIN or RAMPING, <tt class="docutils literal"><span class="pre">rampCount</span> <span class="pre">&gt;</span> <span class="pre">0</span></tt>; in
COLLECTING or OUTSIDE, <tt class="docutils literal"><span class="pre">rampCount</span> <span class="pre">==</span> <span class="pre">0</span></tt>), but this isn&#8217;t checked in
<tt class="xref c c-func docutils literal"><span class="pre">AMCCheck()</span></tt> and in fact is false for COLLECTING (see below).</p>
<p>There is a small set of events causing state machine transitions:</p>
<ul class="simple">
<li>entering an outermost ramp;</li>
<li>leaving an outermost ramp;</li>
<li>condemning any segment of a ramp generation (detected in AMCWhiten);</li>
<li>reclaiming any AMC segment.</li>
</ul>
<p>Here&#8217;s pseudo-code for all the transition events:</p>
<dl class="docutils">
<dt>Entering an outermost ramp:</dt>
<dd>if not FINISH, go to BEGIN.</dd>
<dt>Leaving an outermost ramp:</dt>
<dd>if RAMPING, go to FINISH. Otherwise, go to OUTSIDE.</dd>
<dt>Condemning a ramp generation segment:</dt>
<dd>If BEGIN, go to RAMPING and make the ramp generation forward
to itself (detach the forwarding buffer and reset its generation).
If FINISH, go to COLLECTING and make the ramp generation
forward to the after-ramp generation.</dd>
<dt>Reclaiming any AMC segment:</dt>
<dd><dl class="first last docutils">
<dt>If COLLECTING:</dt>
<dd>if <tt class="docutils literal"><span class="pre">rampCount</span> <span class="pre">&gt;</span> <span class="pre">0</span></tt>, go to BEGIN. Otherwise go to OUTSIDE.</dd>
</dl>
</dd>
</dl>
<p>Now, some deductions:</p>
<p>1. When OUTSIDE, the count is always zero, because (a) it starts that
way, and the only ways to go OUTSIDE are (b) by leaving an outermost
ramp (count goes to zero) or (c) by reclaiming when the count is zero.</p>
<p>2. When BEGIN, the count is never zero (consider the transitions to
BEGIN and the transition to zero).</p>
<p>3. When RAMPING, the count is never zero (again consider transitions to
RAMPING and the transition to zero).</p>
<p>4. When FINISH, the count can be anything (the transition to FINISH has
zero count, but the Enter transition when FINISH can change that and
then it can increment to any value).</p>
<p>5. When COLLECTING, the count can be anything (from the previous fact,
and the transition to COLLECTING).</p>
<p>6. <em>This is a bug!!</em> The ramp generation is not always reset (to forward
to the after-ramp generation). If we get into FINISH and then see
another ramp before the next condemnation of the ramp generation, we
will Enter followed by Leave. The Enter will keep us in FINISH, and
the Leave will take us back to OUTSIDE, skipping the transition to the
COLLECTING state which is what resets the ramp generation forwarding
buffer. [TODO: check whether I made an issue and/or fixed it; NB 2013-06-04]</p>
<p>The simplest change to fix this is to change the behaviour of the Leave
transition, which should only take us OUTSIDE if we are in BEGIN or
COLLECTING. We should also update design/poolamc to tell the truth, and
check the invariants, which will be these:</p>
<blockquote>
<div>OUTSIDE =&gt; zero
BEGIN =&gt; non-zero
RAMPING =&gt; non-zero</div></blockquote>
<p>A cleverer change might radically rearrange the state machine
(e.g. reduce the number of states to three) but that would require
closer design thought and should probably be postponed until we have a
clearer overall strategy plan.</p>
<p>While I&#8217;m writing pseudo-code versions of ramp-related code, I should
mention this other snippet, which is the only other code relating to
ramping (these notes are useful when thinking about the broader strategy
code):</p>
<blockquote>
<div>In <a class="reference internal" href="poolamc.html#AMCBufferFill" title="AMCBufferFill"><tt class="xref c c-func docutils literal"><span class="pre">AMCBufferFill()</span></tt></a>, if we&#8217;re RAMPING, and filling the forwarding
buffer of the ramp generation, and the ramp generation is the
forwarding buffer&#8217;s generation, set <tt class="docutils literal"><span class="pre">amcSeg-&gt;new</span></tt> to FALSE. Otherwise,
add the segment size to <tt class="docutils literal"><span class="pre">poolGen.newSize</span></tt>.</div></blockquote>
<p>And since I&#8217;ve now mentioned the <tt class="docutils literal"><span class="pre">amcSeg-&gt;new</span></tt> flag, here are the only
other uses of that:</p>
<ul class="simple">
<li>it initializes as TRUE.</li>
<li>When leaving an outermost ramp, go through all the segments in the
pool. Any non-white segment in the rampGen with new set to FALSE has
its size added to <tt class="docutils literal"><span class="pre">poolGen-&gt;newSize</span></tt> and gets new set to TRUE.</li>
<li>in <tt class="xref c c-func docutils literal"><span class="pre">AMCWhiten()</span></tt>, if new is TRUE, the segment size is deducted
from <tt class="docutils literal"><span class="pre">poolGen.newSize</span></tt> and new is set to FALSE.</li>
</ul>
</div>
<div class="section" id="non-amc-pools">
<h3>Non-AMC Pools<a class="headerlink" href="#non-amc-pools" title="Permalink to this headline"></a></h3>
<p>The implementations of AMS, AWL, and LO pool classes are all aware of
generations (this is necessary because all tracing is driven by the
generational data structures described above), but do not make use of
them. For LO and AWL, when a pool is created, a chain with a single
generation is also created, with size and mortality parameters
hard-wired into the pool-creation function (LOInit, AWLInit). For
AMS, a chain is passed as a pool creation parameter into
<a class="reference internal" href="../topic/pool.html#mps_pool_create" title="mps_pool_create"><tt class="xref c c-func docutils literal"><span class="pre">mps_pool_create()</span></tt></a>, but this chain must also have only a
single generation (otherwise <tt class="docutils literal"><span class="pre">ResPARAM</span></tt> is returned).</p>
<p>Note that these chains are separate from any chain used by an AMC pool
(except in the trivial case when a single-generation chain is used for
both AMC and AMS). Note also that these pools do not use or point to
the <tt class="docutils literal"><span class="pre">arena-&gt;topGen</span></tt>, which applies only to AMC.</p>
<p>Non-AMC pools have no support for ramps.</p>
</div>
<div class="section" id="starting-a-trace">
<h3>Starting a Trace<a class="headerlink" href="#starting-a-trace" title="Permalink to this headline"></a></h3>
<p>TODO: Why do we start a trace? How do we choose what to condemn?</p>
</div>
<div class="section" id="trace-progress">
<h3>Trace Progress<a class="headerlink" href="#trace-progress" title="Permalink to this headline"></a></h3>
<p>TODO: When do we do some tracing work? How much tracing work do we do?</p>
</div>
</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="#">MPS Strategy</a><ul>
<li><a class="reference internal" href="#introduction">Introduction</a></li>
<li><a class="reference internal" href="#overview">Overview</a></li>
<li><a class="reference internal" href="#requirements">Requirements</a></li>
<li><a class="reference internal" href="#generations">Generations</a><ul>
<li><a class="reference internal" href="#data-structures">Data Structures</a></li>
<li><a class="reference internal" href="#zones">Zones</a></li>
<li><a class="reference internal" href="#accounting">Accounting</a></li>
<li><a class="reference internal" href="#ramps">Ramps</a></li>
<li><a class="reference internal" href="#non-amc-pools">Non-AMC Pools</a></li>
<li><a class="reference internal" href="#starting-a-trace">Starting a Trace</a></li>
<li><a class="reference internal" href="#trace-progress">Trace Progress</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Downloads</h4>
<p class="topless">
<a href="http://www.ravenbrook.com/project/mps/release/1.111.0/">MPS Kit release 1.111.0</a><br>
<a href="http://www.ravenbrook.com/project/mps/release/">All MPS Kit releases</a>
</p>
<h4>Issues</h4>
<p class="topless">
<a href="http://www.ravenbrook.com/project/mps/issue/?action=list&amp;view=status%3dopen&amp;display=Job:Priority:Title&amp;sort=Priority">Known issues</a><br>
<a href="http://www.ravenbrook.com/project/mps/issue/?action=fixed&release_fixed=1.111.0">Issues fixed in release 1.111.0</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><a href="../index.html">Memory Pool System 1.111.0 documentation</a> &raquo;</li>
</ul>
</div>
<div class="footer">
&copy; <a href="../copyright.html">Copyright</a> 2013, Ravenbrook Limited.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
</body>
</html>

8
mps/manual/html/design/trace.html
View file

@ -73,13 +73,13 @@ <h2>44.2. Architecture<a class="headerlink" href="#architecture" title="Permalin
<tt class="xref c c-macro docutils literal"><span class="pre">TRACE_MAX</span></tt>.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last"><tt class="xref c c-macro docutils literal"><span class="pre">TRACE_MAX</span></tt> is currently set to 1, see request.mps.160020
<p class="last"><tt class="xref c c-macro docutils literal"><span class="pre">TRACE_MAX</span></tt> is currently set to 1, see <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/mps/160020">request.mps.160020</a>
&#8220;Multiple traces would not work&#8221;. David Jones, 1998-06-15.</p>
</div>
<p><span class="target" id="design.mps.trace.rate"></span><a class="mpstag reference internal" href="#design.mps.trace.rate">.rate:</a> See <a class="reference external" href="/project/mps/mail/1997/07/31/14-37/0.txt">mail.nickb.1997-07-31.14-37</a>.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">Now revised? See request.epcore.160062 and
<p class="last">Now revised? See <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160062">request.epcore.160062</a> and
change.epcore.minnow.160062. David Jones, 1998-06-15.</p>
</div>
<p><span class="target" id="design.mps.trace.exact.legal"></span><a class="mpstag reference internal" href="#design.mps.trace.exact.legal">.exact.legal:</a> Exact references should either point outside the
@ -108,7 +108,7 @@ <h2>44.3. Analysis<a class="headerlink" href="#analysis" title="Permalink to thi
referenced object has failed (due to lack of memory, for example), by
backing off to treating a reference as ambiguous. Assuming that fixing
an ambiguous reference doesn&#8217;t allocate memory (which is no longer
true for AMC for example). See request.dylan.170560 for a slightly
true for AMC for example). See <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170560">request.dylan.170560</a> for a slightly
more sophisticated way to proceed when you can no longer allocate
memory for copying.</p>
</div>
@ -155,7 +155,7 @@ <h3>44.5.1. Speed<a class="headerlink" href="#speed" title="Permalink to this he
the Dylan compiler.</p>
<p><span class="target" id="design.mps.trace.reclaim"></span><a class="mpstag reference internal" href="#design.mps.trace.reclaim">.reclaim:</a> Because the reclaim phase of the trace (implemented by
<tt class="xref c c-func docutils literal"><span class="pre">TraceReclaim()</span></tt>) examines every segment it is fairly time intensive.
rit&#8217;s profiles presented in request.dylan.170551 show a gap between
rit&#8217;s profiles presented in <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/dylan/170551">request.dylan.170551</a> show a gap between
the two varieties variety.hi and variety.wi.</p>
<p><span class="target" id="design.mps.trace.reclaim.noaver"></span><a class="mpstag reference internal" href="#design.mps.trace.reclaim.noaver">.reclaim.noaver:</a> Converting <tt class="xref c c-func docutils literal"><span class="pre">AVER()</span></tt> statements in the loops of
<tt class="xref c c-func docutils literal"><span class="pre">TraceReclaim()</span></tt>, <tt class="xref c c-func docutils literal"><span class="pre">PoolReclaim()</span></tt>, <a class="reference internal" href="poolamc.html#AMCReclaim" title="AMCReclaim"><tt class="xref c c-func docutils literal"><span class="pre">AMCReclaim()</span></tt></a> (<a class="reference internal" href="poollo.html#LOReclaim" title="LOReclaim"><tt class="xref c c-func docutils literal"><span class="pre">LOReclaim()</span></tt></a>?

2
mps/manual/html/design/version-library.html
View file

@ -69,7 +69,7 @@ <h2>46.2. Readership<a class="headerlink" href="#readership" title="Permalink to
<div class="section" id="source">
<h2>46.3. Source<a class="headerlink" href="#source" title="Permalink to this headline"></a></h2>
<p><span class="target" id="design.mps.version-library.source"></span><a class="mpstag reference internal" href="#design.mps.version-library.source">.source:</a> Various requirements demand such a mechanism. See
request.epcore.160021: There is no way to tell which version and
<a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160021">request.epcore.160021</a>: There is no way to tell which version and
release of the MM one is using.</p>
</div>
<div class="section" id="overview">

4
mps/manual/html/design/vm.html
View file

@ -145,10 +145,10 @@ <h2>48.4. Notes<a class="headerlink" href="#notes" title="Permalink to this head
<a class="reference internal" href="#VMCreate" title="VMCreate"><tt class="xref c c-func docutils literal"><span class="pre">VMCreate()</span></tt></a>) must fail in a predictable way.</p>
<p><span class="target" id="design.mps.vm.testing.larger"></span><a class="mpstag reference internal" href="#design.mps.vm.testing.larger">.testing.larger:</a> It must be possible to allocate in a large space;
sometimes commiting will fail, because there&#8217;s not enough space to
replace the &#8220;reserve&#8221; mapping. See request.epcore.160201 for details.</p>
replace the &#8220;reserve&#8221; mapping. See <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160201">request.epcore.160201</a> for details.</p>
<p><span class="target" id="design.mps.vm.testing.lots"></span><a class="mpstag reference internal" href="#design.mps.vm.testing.lots">.testing.lots:</a> It must be possible to have lots of mappings. The OS
must either combine adjacent mappings or have lots of space in the
kernel tables. See request.epcore.160117 for ideas on how to test
kernel tables. See <a class="reference external" href="https://info.ravenbrook.com/project/mps/import/2001-11-05/mmprevol/request/epcore/160117">request.epcore.160117</a> for ideas on how to test
this.</p>
</div>
</div>

63
mps/manual/html/genindex.html
View file

@ -1315,7 +1315,7 @@ <h2 id="C">C</h2>
</dt>
<dt><a href="topic/format.html#index-2">object format</a>
<dt><a href="topic/format.html#index-3">object format</a>
</dt>
@ -2246,7 +2246,7 @@ <h2 id="F">F</h2>
</dt>
<dt><a href="glossary/f.html#term-fencepost"><strong>fencepost</strong></a>, <a href="topic/debugging.html#index-1">[1]</a>
<dt><a href="topic/debugging.html#index-1">fencepost</a>, <a href="glossary/f.html#term-fencepost"><strong>[1]</strong></a>
</dt>
@ -2352,7 +2352,7 @@ <h2 id="F">F</h2>
</dl></dd>
<dt><a href="topic/format.html#index-3">format method</a>, <a href="glossary/f.html#term-format-method"><strong>[1]</strong></a>
<dt><a href="topic/format.html#index-4">format method</a>, <a href="glossary/f.html#term-format-method"><strong>[1]</strong></a>
</dt>
<dd><dl>
@ -2707,6 +2707,10 @@ <h2 id="H">H</h2>
<dt><a href="topic/interface.html#index-3">interface</a>
</dt>
<dt><a href="topic/format.html#index-2">object format</a>
</dt>
</dl></dd>
<dt><a href="glossary/h.html#term-heap"><strong>heap</strong></a>
@ -2821,6 +2825,17 @@ <h2 id="I">I</h2>
</dt>
<dt>
in-band headers
</dt>
<dd><dl>
<dt><a href="topic/format.html#index-2">object format</a>
</dt>
</dl></dd>
<dt><a href="glossary/i.html#term-in-out-parameter"><strong>in/out parameter</strong></a>
</dt>
@ -2840,12 +2855,12 @@ <h2 id="I">I</h2>
<dt><a href="design/type.html#Index">Index (C type)</a>
</dt>
</dl></td>
<td style="width: 33%" valign="top"><dl>
<dt><a href="glossary/i.html#term-indexed-fit"><strong>indexed fit</strong></a>
</dt>
</dl></td>
<td style="width: 33%" valign="top"><dl>
<dt><a href="glossary/i.html#term-indirect-method"><strong>indirect method</strong></a>
</dt>
@ -2954,7 +2969,7 @@ <h2 id="I">I</h2>
</dt>
<dt><a href="topic/format.html#index-4">object format</a>
<dt><a href="topic/format.html#index-5">object format</a>
</dt>
@ -4117,6 +4132,14 @@ <h2 id="M">M</h2>
</dt>
<dt><a href="topic/format.html#mps_fmt_create_fixed">mps_fmt_create_fixed (C function)</a>
</dt>
<dt><a href="topic/format.html#mps_fmt_create_k">mps_fmt_create_k (C function)</a>
</dt>
<dt><a href="topic/format.html#mps_fmt_destroy">mps_fmt_destroy (C function)</a>
</dt>
@ -4125,6 +4148,10 @@ <h2 id="M">M</h2>
</dt>
<dt><a href="topic/format.html#mps_fmt_fixed_s">mps_fmt_fixed_s (C type)</a>
</dt>
<dt><a href="topic/format.html#mps_fmt_fwd_t">mps_fmt_fwd_t (C type)</a>
</dt>
@ -4140,12 +4167,12 @@ <h2 id="M">M</h2>
<dt><a href="design/object-debug.html#mps_fmt_put_fencepost_t">mps_fmt_put_fencepost_t (C function)</a>
</dt>
</dl></td>
<td style="width: 33%" valign="top"><dl>
<dt><a href="topic/format.html#mps_fmt_scan_t">mps_fmt_scan_t (C type)</a>
</dt>
</dl></td>
<td style="width: 33%" valign="top"><dl>
<dt><a href="topic/format.html#mps_fmt_skip_t">mps_fmt_skip_t (C type)</a>
</dt>
@ -5011,15 +5038,23 @@ <h2 id="O">O</h2>
<dd><dl>
<dt><a href="topic/format.html#index-2">cautions</a>
<dt><a href="topic/format.html#index-3">cautions</a>
</dt>
<dt><a href="topic/format.html#index-1">creating</a>
<dt><a href="topic/format.html#index-4">format method</a>
</dt>
<dt><a href="topic/format.html#index-3">format method</a>
<dt><a href="topic/format.html#index-2">headers</a>
</dt>
<dt><a href="topic/format.html#index-2">in-band headers</a>
</dt>
<dt><a href="topic/format.html#index-1">interface</a>
</dt>
@ -5027,7 +5062,7 @@ <h2 id="O">O</h2>
</dt>
<dt><a href="topic/format.html#index-4">introspection</a>
<dt><a href="topic/format.html#index-5">introspection</a>
</dt>
@ -5088,7 +5123,7 @@ <h2 id="P">P</h2>
</dt>
<dt><a href="glossary/p.html#term-padding-method"><strong>padding method</strong></a>, <a href="guide/lang.html#index-9">[1]</a>
<dt><a href="guide/lang.html#index-9">padding method</a>, <a href="glossary/p.html#term-padding-method"><strong>[1]</strong></a>
</dt>
@ -5136,7 +5171,7 @@ <h2 id="P">P</h2>
</dt>
<dt><a href="glossary/p.html#term-parked-state"><strong>parked state</strong></a>, <a href="topic/arena.html#index-8">[1]</a>
<dt><a href="topic/arena.html#index-8">parked state</a>, <a href="glossary/p.html#term-parked-state"><strong>[1]</strong></a>
</dt>

9
mps/manual/html/glossary/i.html
View file

@ -159,10 +159,17 @@ <h3>Navigation</h3>
<p class="first admonition-title">Opposite term</p>
<p class="last"><a class="reference internal" href="o.html#term-out-of-band-header"><em class="xref std std-term">out-of-band header</em></a>.</p>
</div>
<div class="admonition-see-also last admonition seealso">
<div class="admonition-see-also admonition seealso">
<p class="first admonition-title">See also</p>
<p class="last"><a class="reference internal" href="s.html#term-stack-frame"><em class="xref std std-term">stack frame</em></a>, <a class="reference internal" href="a.html#term-activation-frame"><em class="xref std std-term">activation frame</em></a>.</p>
</div>
<div class="admonition-in-the-mps last admonition">
<p class="first admonition-title">In the MPS</p>
<p class="last">In-band headers are supported by some <a class="reference internal" href="p.html#term-pool-class"><em class="xref std std-term">pool classes</em></a>
and the size of the header is specified by passing the
<tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_HEADER_SIZE</span></tt> <a class="reference internal" href="k.html#term-keyword-argument"><em class="xref std std-term">keyword
argument</em></a> to <a class="reference internal" href="../topic/format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a>.</p>
</div>
</dd>
<dt id="term-in-parameter">in parameter</dt>
<dd><p class="first">A function parameter that supplies data from the caller to the

23
mps/manual/html/guide/advanced.html
View file

@ -659,22 +659,15 @@ <h3>Navigation</h3>
<span class="p">}</span>
</pre></div>
</div>
<p>as is the object format, since AWL only calls the scan and skip
methods:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">mps_fmt_A_s</span> <span class="n">buckets_fmt_s</span> <span class="o">=</span> <span class="p">{</span>
<span class="n">ALIGNMENT</span><span class="p">,</span>
<span class="n">buckets_scan</span><span class="p">,</span>
<span class="n">buckets_skip</span><span class="p">,</span>
<span class="nb">NULL</span><span class="p">,</span> <span class="cm">/* Obsolete copy method */</span>
<span class="nb">NULL</span><span class="p">,</span> <span class="cm">/* fwd method not used by AWL */</span>
<span class="nb">NULL</span><span class="p">,</span> <span class="cm">/* isfwd method not used by AWL */</span>
<span class="nb">NULL</span> <span class="cm">/* pad method not used by AWL */</span>
<span class="p">};</span>
</pre></div>
</div>
<p>Finally, we can create the buckets pool and its allocation points:</p>
<p>Now we can create the object format, the pool and the allocation
points:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="cm">/* Create the buckets format. */</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_fmt_create_A</span><span class="p">(</span><span class="o">&amp;</span><span class="n">buckets_fmt</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">buckets_fmt_s</span><span class="p">);</span>
<span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_ALIGN</span><span class="p">,</span> <span class="n">ALIGNMENT</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_SCAN</span><span class="p">,</span> <span class="n">buckets_scan</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_SKIP</span><span class="p">,</span> <span class="n">buckets_skip</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_fmt_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">buckets_fmt</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">res</span> <span class="o">!=</span> <span class="n">MPS_RES_OK</span><span class="p">)</span> <span class="n">error</span><span class="p">(</span><span class="s">&quot;Couldn&#39;t create buckets format&quot;</span><span class="p">);</span>
<span class="cm">/* Create an Automatic Weak Linked (AWL) pool to manage the hash table</span>

20
mps/manual/html/guide/build.html
View file

@ -314,13 +314,25 @@ <h3>2.5.1. mpseventsql<a class="headerlink" href="#mpseventsql" title="Permalink
<p>The MPS Kit can build a command-line program <tt class="docutils literal"><span class="pre">mpseventsql</span></tt> that
loads a diagnostic stream of events into a <a class="reference external" href="http://www.sqlite.org/">SQLite3</a> database for processing. In order to build
this program, you need to install the SQLite3 development resources.</p>
<p>On Mac OS X, SQLite3 is pre-installed, so this tool builds by default.</p>
<p>On Linux, you need to install the <tt class="docutils literal"><span class="pre">libsqlite3-dev</span></tt> package:</p>
<ul>
<li><p class="first">On Mac OS X, SQLite3 is pre-installed, so this tool builds by
default.</p>
</li>
<li><p class="first">On Linux, you need to install the <tt class="docutils literal"><span class="pre">libsqlite3-dev</span></tt> package:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">apt</span><span class="o">-</span><span class="n">get</span> <span class="n">install</span> <span class="n">libsqlite3</span><span class="o">-</span><span class="n">dev</span>
</pre></div>
</div>
<p>and then re-run <tt class="docutils literal"><span class="pre">./configure</span></tt> and <tt class="docutils literal"><span class="pre">make</span></tt> as described above.</p>
<p>On Windows, you should visit the <a class="reference external" href="http://www.sqlite.org/download.html">SQLite Download Page</a> and download the
</li>
<li><p class="first">On FreeBSD, you need to build and install the <tt class="docutils literal"><span class="pre">databases/sqlite3</span></tt>
port from the ports collection:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">cd</span> <span class="o">/</span><span class="n">usr</span><span class="o">/</span><span class="n">ports</span><span class="o">/</span><span class="n">databases</span><span class="o">/</span><span class="n">sqlite3</span>
<span class="n">make</span> <span class="n">install</span> <span class="n">clean</span>
</pre></div>
</div>
<p>and then re-run <tt class="docutils literal"><span class="pre">./configure</span></tt> and <tt class="docutils literal"><span class="pre">make</span></tt> as described above.</p>
</li>
<li><p class="first">On Windows, you should visit the <a class="reference external" href="http://www.sqlite.org/download.html">SQLite Download Page</a> and download the
<tt class="docutils literal"><span class="pre">sqlite-amalgamation</span></tt> ZIP archive. (At time of writing this is the
first download on the page.) When you unzip the archive, you&#8217;ll find
it contains files named <tt class="docutils literal"><span class="pre">sqlite3.c</span></tt> and <tt class="docutils literal"><span class="pre">sqlite3.h</span></tt>. Copy these
@ -330,6 +342,8 @@ <h3>2.5.1. mpseventsql<a class="headerlink" href="#mpseventsql" title="Permalink
<div class="highlight-c"><div class="highlight"><pre><span class="n">nmake</span> <span class="o">/</span><span class="n">f</span> <span class="n">w3i3mv</span><span class="p">.</span><span class="n">nmk</span> <span class="n">mpseventsql</span><span class="p">.</span><span class="n">exe</span>
</pre></div>
</div>
</li>
</ul>
</div>
</div>
</div>

44
mps/manual/html/guide/lang.html
View file

@ -266,28 +266,24 @@ <h3>Navigation</h3>
<a class="reference internal" href="../glossary/f.html#term-forwarding-object"><em class="xref std std-term">forwarding</em></a> or <a class="reference internal" href="../glossary/p.html#term-padding-object"><em class="xref std std-term">padding object</em></a>, and
so on). You do this by creating an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>. Here&#8217;s the
code for creating the object format for the toy Scheme interpreter:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">mps_fmt_A_s</span> <span class="n">obj_fmt_s</span> <span class="o">=</span> <span class="p">{</span>
<span class="n">ALIGNMENT</span><span class="p">,</span>
<span class="n">obj_scan</span><span class="p">,</span>
<span class="n">obj_skip</span><span class="p">,</span>
<span class="nb">NULL</span><span class="p">,</span>
<span class="n">obj_fwd</span><span class="p">,</span>
<span class="n">obj_isfwd</span><span class="p">,</span>
<span class="n">obj_pad</span><span class="p">,</span>
<span class="p">};</span>
<span class="kt">mps_fmt_t</span> <span class="n">obj_fmt</span><span class="p">;</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_fmt_create_A</span><span class="p">(</span><span class="o">&amp;</span><span class="n">obj_fmt</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">obj_fmt_s</span><span class="p">);</span>
<div class="highlight-c"><div class="highlight"><pre><span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_ALIGN</span><span class="p">,</span> <span class="n">ALIGNMENT</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_SCAN</span><span class="p">,</span> <span class="n">obj_scan</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_SKIP</span><span class="p">,</span> <span class="n">obj_skip</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_FWD</span><span class="p">,</span> <span class="n">obj_fwd</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_ISFWD</span><span class="p">,</span> <span class="n">obj_isfwd</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_PAD</span><span class="p">,</span> <span class="n">obj_pad</span><span class="p">);</span>
<span class="n">MPS_ARGS_DONE</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_fmt_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">obj_fmt</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">res</span> <span class="o">!=</span> <span class="n">MPS_RES_OK</span><span class="p">)</span> <span class="n">error</span><span class="p">(</span><span class="s">&quot;Couldn&#39;t create obj format&quot;</span><span class="p">);</span>
</pre></div>
</div>
<p>The structure <a class="reference internal" href="../topic/format.html#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a> is the simplest of several object
format variants that are appropriate for moving pools like AMC.</p>
<p>The first element of the structure is the <a class="reference internal" href="../glossary/a.html#term-alignment"><em class="xref std std-term">alignment</em></a> of objects
belonging to this format. Determining the alignment is hard to do
portably, because it depends on the target architecture and on the way
the compiler lays out its structures in memory. Here are some things
you might try:</p>
<p>The argument for the keyword <tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_ALIGN</span></tt> is the
<a class="reference internal" href="../glossary/a.html#term-alignment"><em class="xref std std-term">alignment</em></a> of objects belonging to this format. Determining the
alignment is hard to do portably, because it depends on the target
architecture and on the way the compiler lays out its structures in
memory. Here are some things you might try:</p>
<ol class="arabic">
<li><p class="first">Some modern compilers support the <tt class="docutils literal"><span class="pre">alignof</span></tt> operator:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="cp">#define ALIGNMENT alignof(obj_s)</span>
@ -313,10 +309,9 @@ <h3>Navigation</h3>
</div>
</li>
</ol>
<p>The other elements of the structure are the <a class="reference internal" href="../glossary/f.html#term-format-method"><em class="xref std std-term">format methods</em></a>,
which are described in the following sections. (The <tt class="docutils literal"><span class="pre">NULL</span></tt> in the
structure is a placeholder for the <a class="reference internal" href="../glossary/c.html#term-copy-method"><em class="xref std std-term">copy method</em></a>, which is now
obsolete.)</p>
<p>The other keyword arguments specify the <a class="reference internal" href="../glossary/f.html#term-format-method"><em class="xref std std-term">format methods</em></a>
required by the AMC pool class, which are described in the following
sections.</p>
<div class="admonition-topic admonition">
<p class="first admonition-title">Topic</p>
<p class="last"><a class="reference internal" href="../topic/format.html#topic-format"><em>Object formats</em></a>.</p>
@ -1095,7 +1090,8 @@ <h3>Navigation</h3>
were created in an <a class="reference internal" href="../glossary/a.html#term-arena"><em class="xref std std-term">arena</em></a> before destroying the arena, and so
on.</p>
<p>Here&#8217;s the tear-down code from the toy Scheme interpreter:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">mps_ap_destroy</span><span class="p">(</span><span class="n">obj_ap</span><span class="p">);</span>
<div class="highlight-c"><div class="highlight"><pre><span class="n">mps_arena_park</span><span class="p">(</span><span class="n">arena</span><span class="p">);</span>
<span class="n">mps_ap_destroy</span><span class="p">(</span><span class="n">obj_ap</span><span class="p">);</span>
<span class="n">mps_pool_destroy</span><span class="p">(</span><span class="n">obj_pool</span><span class="p">);</span>
<span class="n">mps_chain_destroy</span><span class="p">(</span><span class="n">obj_chain</span><span class="p">);</span>
<span class="n">mps_fmt_destroy</span><span class="p">(</span><span class="n">obj_fmt</span><span class="p">);</span>

BIN
mps/manual/html/objects.inv
View file

Binary file not shown.

7
mps/manual/html/pool/amc.html
View file

@ -98,11 +98,14 @@ <h3>Navigation</h3>
automatically <a class="reference internal" href="../glossary/r.html#term-reclaim"><em class="xref std std-term">reclaimed</em></a>.</li>
<li>Blocks are <a class="reference internal" href="../glossary/s.html#term-scan"><em class="xref std std-term">scanned</em></a>.</li>
<li>Blocks may only be referenced by <a class="reference internal" href="../glossary/b.html#term-base-pointer"><em class="xref std std-term">base pointers</em></a> (unless they
belong to an object format of variant auto-header).</li>
have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>).</li>
<li>Blocks may be protected by <a class="reference internal" href="../glossary/b.html#term-barrier-1"><em class="xref std std-term">barriers<sup>(1)</sup></em></a>.</li>
<li>Blocks may <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>.</li>
<li>Blocks may be registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> which provides
<a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan</em></a>, <a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip</em></a>,
<a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward</em></a>, <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded</em></a>, and <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding</em></a> methods.</li>
<li>Blocks may have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>.</li>
</ul>
</div>
<div class="section" id="amc-interface">

11
mps/manual/html/pool/ams.html
View file

@ -98,14 +98,13 @@ <h3>Navigation</h3>
automatically <a class="reference internal" href="../glossary/r.html#term-reclaim"><em class="xref std std-term">reclaimed</em></a>.</li>
<li>Blocks are <a class="reference internal" href="../glossary/s.html#term-scan"><em class="xref std std-term">scanned</em></a>.</li>
<li>Blocks may only be referenced by <a class="reference internal" href="../glossary/b.html#term-base-pointer"><em class="xref std std-term">base pointers</em></a> (unless they
belong to an object format of variant auto-header).</li>
have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>).</li>
<li>Blocks are not protected by <a class="reference internal" href="../glossary/b.html#term-barrier-1"><em class="xref std std-term">barriers<sup>(1)</sup></em></a>.</li>
<li>Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>. A consequence
of this is that the pool&#8217;s <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> need not provide a
<a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a>, an <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded method</em></a> or a
<a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a>.</li>
<li>Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>.</li>
<li>Blocks may be registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> which provides
<a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan</em></a> and <a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip</em></a> methods.</li>
<li>Blocks may have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>.</li>
</ul>
</div>
<div class="section" id="ams-interface">

12
mps/manual/html/pool/awl.html
View file

@ -125,18 +125,18 @@ <h3>Navigation</h3>
<li><p class="first">Blocks are <a class="reference internal" href="../glossary/s.html#term-scan"><em class="xref std std-term">scanned</em></a>.</p>
</li>
<li><p class="first">Blocks may only be referenced by <a class="reference internal" href="../glossary/b.html#term-base-pointer"><em class="xref std std-term">base pointers</em></a> (unless they
belong to an object format of variant auto-header).</p>
have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>).</p>
</li>
<li><p class="first">Blocks may be protected by <a class="reference internal" href="../glossary/b.html#term-barrier-1"><em class="xref std std-term">barriers<sup>(1)</sup></em></a>.</p>
</li>
<li><p class="first">Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>. A consequence
of this is that the pool&#8217;s <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> need not provide a
<a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a>, an <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded method</em></a> or a
<a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a>.</p>
<li><p class="first">Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>.</p>
</li>
<li><p class="first">Blocks may be registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a>.</p>
</li>
<li><p class="first">Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>.</p>
<li><p class="first">Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> which provides
<a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan</em></a> and <a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip</em></a> methods.</p>
</li>
<li><p class="first">Blocks may have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>.</p>
</li>
</ul>
</div>

8
mps/manual/html/pool/intro.html
View file

@ -488,7 +488,7 @@ <h3>Navigation</h3>
<td>no</td>
<td>yes</td>
</tr>
<tr class="row-odd"><td>Blocks may belong to format auto-header?</td>
<tr class="row-odd"><td>Blocks may use <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>?</td>
<td>yes</td>
<td>yes</td>
<td>yes</td>
@ -600,9 +600,9 @@ <h3>Navigation</h3>
location within the block is considered to be a reference
to the block. It &#8220;supports base pointers only&#8221; if only a
pointer to the base of the block (or, if the block belongs
to an object format of variant auto-header, a pointer just
past the end of the header) is considered to be a reference
to the block.</td></tr>
to an object format with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>, a pointer
just past the end of the header) is considered to be a
reference to the block.</td></tr>
</tbody>
</table>
</div>

11
mps/manual/html/pool/lo.html
View file

@ -99,14 +99,13 @@ <h3>Navigation</h3>
the pool&#8217;s <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> need not provide a <a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan
method</em></a>.</li>
<li>Blocks may only be referenced by <a class="reference internal" href="../glossary/b.html#term-base-pointer"><em class="xref std std-term">base pointers</em></a> (unless they
belong to an object format of variant auto-header).</li>
have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>).</li>
<li>Blocks are not protected by <a class="reference internal" href="../glossary/b.html#term-barrier-1"><em class="xref std std-term">barriers<sup>(1)</sup></em></a>.</li>
<li>Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>. A consequence
of this is that the pool&#8217;s <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> need not provide a
<a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a> or an <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded method</em></a>. (It also
does not need a <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a>.)</li>
<li>Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>.</li>
<li>Blocks may be registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> which provides
<a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan</em></a> and <a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip</em></a> methods.</li>
<li>Blocks may have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>.</li>
</ul>
</div>
<div class="section" id="lo-interface">

6
mps/manual/html/pool/mfs.html
View file

@ -104,7 +104,7 @@ <h3>Navigation</h3>
<dd><p>Return the <a class="reference internal" href="../glossary/p.html#term-pool-class"><em class="xref std std-term">pool class</em></a> for an MFS (Manual Fixed Small)
<a class="reference internal" href="../glossary/p.html#term-pool"><em class="xref std std-term">pool</em></a>.</p>
<p>When creating an MFS pool, <a class="reference internal" href="../topic/pool.html#mps_pool_create_k" title="mps_pool_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_pool_create_k()</span></tt></a> requires
one <a class="reference internal" href="../glossary/k.html#term-keyword-argument"><em class="xref std std-term">keyword arguments</em></a>:</p>
one <a class="reference internal" href="../glossary/k.html#term-keyword-argument"><em class="xref std std-term">keyword argument</em></a>:</p>
<ul class="simple">
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MFS_UNIT_SIZE</span></tt> (type <tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt>) is the
<a class="reference internal" href="../glossary/s.html#term-size"><em class="xref std std-term">size</em></a> of blocks that will be allocated from this pool, in
@ -121,8 +121,8 @@ <h3>Navigation</h3>
</ul>
<p>For example:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MFS_UNIT_SIZE</span><span class="p">,</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_EXTEND_BY</span><span class="p">,</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MFS_UNIT_SIZE</span><span class="p">,</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_EXTEND_BY</span><span class="p">,</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_DONE</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_pool_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">pool</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">mps_class_mfs</span><span class="p">(),</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>

6
mps/manual/html/pool/mv.html
View file

@ -114,9 +114,9 @@ <h3>Navigation</h3>
less efficient if these are wrong, but nothing will break.</p>
<p>For example:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MEAN_SIZE</span><span class="p">,</span> <span class="mi">32</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MAX_SIZE</span><span class="p">,</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_EXTEND_BY</span><span class="p">,</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MEAN_SIZE</span><span class="p">,</span> <span class="mi">32</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MAX_SIZE</span><span class="p">,</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_EXTEND_BY</span><span class="p">,</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_DONE</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_pool_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">pool</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">mps_class_mfs</span><span class="p">(),</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>

12
mps/manual/html/pool/mvff.html
View file

@ -173,12 +173,12 @@ <h3>Navigation</h3>
Other combinations may be useful in special circumstances.</p>
<p>For example:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_EXTEND_BY</span><span class="p">,</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MEAN_SIZE</span><span class="p">,</span> <span class="mi">32</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_ALIGN</span><span class="p">,</span> <span class="mi">8</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MVFF_ARENA_HIGH</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MVFF_SLOT_HIGH</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MVFF_FIRST_FIT</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_EXTEND_BY</span><span class="p">,</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MEAN_SIZE</span><span class="p">,</span> <span class="mi">32</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_ALIGN</span><span class="p">,</span> <span class="mi">8</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MVFF_ARENA_HIGH</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MVFF_SLOT_HIGH</span><span class="p">,</span> <span class="mi">1</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MVFF_FIRST_FIT</span><span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
<span class="n">MPS_ARGS_DONE</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_pool_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">pool</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">mps_class_mvff</span><span class="p">(),</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>

10
mps/manual/html/pool/mvt.html
View file

@ -186,11 +186,11 @@ <h3>Navigation</h3>
</ul>
<p>For example:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MIN_SIZE</span><span class="p">,</span> <span class="mi">4</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MEAN_SIZE</span><span class="p">,</span> <span class="mi">32</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MAX_SIZE</span><span class="p">,</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MVT_RESERVE_DEPTH</span><span class="p">,</span> <span class="mi">256</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">ARGS</span><span class="p">,</span> <span class="n">MPS_KEY_MVT_FRAG_LIMIT</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MIN_SIZE</span><span class="p">,</span> <span class="mi">4</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MEAN_SIZE</span><span class="p">,</span> <span class="mi">32</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MAX_SIZE</span><span class="p">,</span> <span class="mi">1024</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MVT_RESERVE_DEPTH</span><span class="p">,</span> <span class="mi">256</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_MVT_FRAG_LIMIT</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">);</span>
<span class="n">MPS_ARGS_DONE</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_pool_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">pool</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">mps_class_mvt</span><span class="p">(),</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>

10
mps/manual/html/pool/snc.html
View file

@ -95,11 +95,11 @@ <h3>Navigation</h3>
<li>Blocks may only be referenced by <a class="reference internal" href="../glossary/b.html#term-base-pointer"><em class="xref std std-term">base pointers</em></a>.</li>
<li>Blocks are not protected by <a class="reference internal" href="../glossary/b.html#term-barrier-1"><em class="xref std std-term">barriers<sup>(1)</sup></em></a>.</li>
<li>Blocks do not <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">move</em></a>.</li>
<li>Blocks may not be registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a>. A consequence
of this is that the pool&#8217;s <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> need not provide a
<a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a> or an <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded method</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>, but this may not be
a format of variant auto-header.</li>
<li>Blocks may not be registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a>.</li>
<li>Blocks must belong to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> which provides
<a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan</em></a>, <a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip</em></a>, and
<a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding</em></a> methods.</li>
<li>Blocks must not have <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>.</li>
</ul>
</div>
<div class="section" id="snc-introspection">

2
mps/manual/html/searchindex.js
View file

File diff suppressed because one or more lines are too long

13
mps/manual/html/topic/finalization.html
View file

@ -199,6 +199,19 @@ <h3>Navigation</h3>
deprecated. See Appendix&nbsp;A of <a class="reference internal" href="../mmref/bib.html#boehm02"><em>Boehm (2002)</em></a>
for a discussion of this problem.</p>
</div>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p>You can safely destroy pools containing objects registered for
finalization if you follow the &#8220;safe tear-down&#8221; procedure
described under <a class="reference internal" href="pool.html#mps_pool_destroy" title="mps_pool_destroy"><tt class="xref c c-func docutils literal"><span class="pre">mps_pool_destroy()</span></tt></a>, but the objects do
not get finalized.</p>
<p class="last">The only reliable way to ensure that all finalizable object
gets finalized is to maintain a table of <a class="reference internal" href="../glossary/w.html#term-weak-reference-1"><em class="xref std std-term">weak
references<sup>(1)</sup></em></a> to all such objects. The weak references don&#8217;t
prevent the objects from being finalized, but you can iterate
over the list at an appropriate point and finalize any
remaining objects yourself.</p>
</div>
</li>
</ol>
<ol class="arabic simple" start="4">

460
mps/manual/html/topic/format.html
View file

@ -75,223 +75,78 @@ <h3>Navigation</h3>
object), and the <a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a> (which replaces an object that
has moved with a <a class="reference internal" href="../glossary/f.html#term-forwarding-object"><em class="xref std std-term">forwarding object</em></a>).</p>
<p>Not every <a class="reference internal" href="../glossary/p.html#term-pool-class"><em class="xref std std-term">pool class</em></a> supports <a class="reference internal" href="../glossary/f.html#term-formatted-object"><em class="xref std std-term">formatted objects</em></a>.</p>
<div class="section" id="interface">
<span id="index-1"></span><h2>7.1. Interface<a class="headerlink" href="#interface" title="Permalink to this headline"></a></h2>
<dl class="type">
<dt id="mps_fmt_t">
<tt class="descname">mps_fmt_t</tt><a class="headerlink" href="#mps_fmt_t" title="Permalink to this definition"></a></dt>
<dd><p>The type of an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>.</p>
</dd></dl>
<div class="section" id="creating-an-object-format">
<span id="index-1"></span><h2>7.1. Creating an object format<a class="headerlink" href="#creating-an-object-format" title="Permalink to this headline"></a></h2>
<p>Different <a class="reference internal" href="../glossary/p.html#term-pool-class"><em class="xref std std-term">pool classes</em></a> use different sets of format methods
and values (for example, a non-moving pool does not need forwarding
objects, so its object formats do not need to contain a forward
method). To accommodate this variance, it is possible to construct
object formats from different collections of format methods and
values. Such a collection is called a <em>format variant</em>.</p>
<p>There are three supported format variants. All are suitable for
copying and moving pools.</p>
<dl class="function">
<dt id="mps_fmt_create_k">
void <tt class="descname">mps_fmt_create_k</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*mps_fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="keyword.html#mps_arg_s" title="mps_arg_s">mps_arg_s</a><em>&nbsp;args[]</em><big>)</big><a class="headerlink" href="#mps_fmt_create_k" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>.</p>
<p><tt class="docutils literal"><span class="pre">fmt_o</span></tt> points to a location that will hold the address of the new
object format.</p>
<p><tt class="docutils literal"><span class="pre">arena</span></tt> is the arena in which to create the format.</p>
<p><tt class="docutils literal"><span class="pre">args</span></tt> are <a class="reference internal" href="../glossary/k.html#term-keyword-argument"><em class="xref std std-term">keyword arguments</em></a> describing the format. Each
<a class="reference internal" href="../glossary/p.html#term-pool-class"><em class="xref std std-term">pool class</em></a> requires a particular subset of these keyword
arguments: see the documentation for that pool class.</p>
<ul class="simple">
<li>Variant A (<a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>): for objects without
<a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">headers</em></a>.</li>
<li>Variant B (<a class="reference internal" href="#mps_fmt_B_s" title="mps_fmt_B_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_B_s</span></tt></a>): as variant A, but with the
addition of a class method.</li>
<li>Variant auto-header (<a class="reference internal" href="#mps_fmt_auto_header_s" title="mps_fmt_auto_header_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_auto_header_s</span></tt></a>): for objects
with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">headers</em></a>.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_ALIGN</span></tt> (type <a class="reference internal" href="interface.html#mps_align_t" title="mps_align_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_align_t</span></tt></a>,
default <a class="reference internal" href="platform.html#MPS_PF_ALIGN" title="MPS_PF_ALIGN"><tt class="xref c c-macro docutils literal"><span class="pre">MPS_PF_ALIGN</span></tt></a>) is an integer value specifying
the alignment of objects allocated with this format. It should
be large enough to satisfy the alignment requirements of any
field in the objects, and it must not be larger than the pool
alignment.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_HEADER_SIZE</span></tt> (type <tt class="xref c c-type docutils literal"><span class="pre">mps_size_t</span></tt>,
default 0) is an integer value specifying the header size for
objects with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>. See
<a class="reference internal" href="#topic-format-headers"><em>In-band headers</em></a> below.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_SCAN</span></tt> (type <a class="reference internal" href="#mps_fmt_scan_t" title="mps_fmt_scan_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_scan_t</span></tt></a>) is a
<a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan method</em></a> that identifies references within objects
belonging to this format. See <a class="reference internal" href="#mps_fmt_scan_t" title="mps_fmt_scan_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_scan_t</span></tt></a>.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_SKIP</span></tt> (type <a class="reference internal" href="#mps_fmt_skip_t" title="mps_fmt_skip_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_skip_t</span></tt></a>) is a
<a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip method</em></a> that skips over objects belonging to this
format. See <a class="reference internal" href="#mps_fmt_skip_t" title="mps_fmt_skip_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_skip_t</span></tt></a>.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_FWD</span></tt> (type <a class="reference internal" href="#mps_fmt_fwd_t" title="mps_fmt_fwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_fwd_t</span></tt></a>) is a
<a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a> that stores relocation information for an
object belonging to this format that has moved. See
<a class="reference internal" href="#mps_fmt_fwd_t" title="mps_fmt_fwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_fwd_t</span></tt></a>.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_ISFWD</span></tt> (type <a class="reference internal" href="#mps_fmt_isfwd_t" title="mps_fmt_isfwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_isfwd_t</span></tt></a>) is
a <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded method</em></a> that determines if an object
belonging to this format has been moved. See
<a class="reference internal" href="#mps_fmt_isfwd_t" title="mps_fmt_isfwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_isfwd_t</span></tt></a>.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_PAD</span></tt> (type <a class="reference internal" href="#mps_fmt_pad_t" title="mps_fmt_pad_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_pad_t</span></tt></a>) is a
<a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a> that creates <a class="reference internal" href="../glossary/p.html#term-padding-object"><em class="xref std std-term">padding objects</em></a>
belonging to this format. See <a class="reference internal" href="#mps_fmt_pad_t" title="mps_fmt_pad_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_pad_t</span></tt></a>.</li>
<li><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_CLASS</span></tt> (type <a class="reference internal" href="#mps_fmt_class_t" title="mps_fmt_class_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_class_t</span></tt></a>) is
a method that returns an address that is related to the class or
type of the object, for inclusion in the <a class="reference internal" href="../glossary/t.html#term-telemetry-stream"><em class="xref std std-term">telemetry
stream</em></a> for some events relating to the object. See
<a class="reference internal" href="#mps_fmt_class_t" title="mps_fmt_class_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_class_t</span></tt></a>.</li>
</ul>
<p>The client program creates an object format by construct a format
variant structure and then calling the appropriate <tt class="docutils literal"><span class="pre">mps_fmt_create_</span></tt>
function for the variant. The variant structure can then be disposed
of.</p>
<p><a class="reference internal" href="#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a> 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> if
successful. The MPS may exhaust some resource in the course of
<a class="reference internal" href="#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a> and will return an appropriate
<a class="reference internal" href="../glossary/r.html#term-result-code"><em class="xref std std-term">result code</em></a> if so.</p>
<p>The object format pointed to by <tt class="docutils literal"><span class="pre">fmt_o</span></tt> persists until it is
destroyed by calling <a class="reference internal" href="#mps_fmt_destroy" title="mps_fmt_destroy"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_destroy()</span></tt></a>.</p>
<p>For example:</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">struct</span> <span class="n">mps_fmt_A_s</span> <span class="n">obj_fmt_s</span> <span class="o">=</span> <span class="p">{</span>
<span class="n">ALIGNMENT</span><span class="p">,</span>
<span class="n">obj_scan</span><span class="p">,</span>
<span class="n">obj_skip</span><span class="p">,</span>
<span class="nb">NULL</span><span class="p">,</span> <span class="cm">/* Obsolete copy method */</span>
<span class="n">obj_fwd</span><span class="p">,</span>
<span class="n">obj_isfwd</span><span class="p">,</span>
<span class="n">obj_pad</span>
<span class="p">};</span>
<span class="kt">mps_pool_t</span> <span class="n">obj_pool</span><span class="p">;</span>
<span class="kt">mps_fmt_t</span> <span class="n">obj_fmt</span><span class="p">;</span>
<span class="kt">mps_res_t</span> <span class="n">res</span><span class="p">;</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_fmt_create_A</span><span class="p">(</span><span class="o">&amp;</span><span class="n">obj_fmt</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">obj_fmt_s</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">res</span> <span class="o">!=</span> <span class="n">MPS_RES_OK</span><span class="p">)</span> <span class="n">error</span><span class="p">(</span><span class="s">&quot;Couldn&#39;t create obj format&quot;</span><span class="p">);</span>
<span class="cm">/* obj_fmt created successfully */</span>
<span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FORMAT</span><span class="p">,</span> <span class="n">obj_fmt</span><span class="p">);</span>
<div class="highlight-c"><div class="highlight"><pre><span class="n">MPS_ARGS_BEGIN</span><span class="p">(</span><span class="n">args</span><span class="p">)</span> <span class="p">{</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_ALIGN</span><span class="p">,</span> <span class="n">ALIGNMENT</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_SCAN</span><span class="p">,</span> <span class="n">obj_scan</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_SKIP</span><span class="p">,</span> <span class="n">obj_skip</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_FWD</span><span class="p">,</span> <span class="n">obj_fwd</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_ISFWD</span><span class="p">,</span> <span class="n">obj_isfwd</span><span class="p">);</span>
<span class="n">MPS_ARGS_ADD</span><span class="p">(</span><span class="n">args</span><span class="p">,</span> <span class="n">MPS_KEY_FMT_PAD</span><span class="p">,</span> <span class="n">obj_pad</span><span class="p">);</span>
<span class="n">MPS_ARGS_DONE</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_pool_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">obj_pool</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">pool_class</span><span class="p">,</span> <span class="n">args</span><span class="p">);</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">mps_fmt_create_k</span><span class="p">(</span><span class="o">&amp;</span><span class="n">obj_fmt</span><span class="p">,</span> <span class="n">arena</span><span class="p">,</span> <span class="n">args</span><span class="p">);</span>
<span class="p">}</span> <span class="n">MPS_ARGS_END</span><span class="p">(</span><span class="n">args</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">res</span> <span class="o">!=</span> <span class="n">MPS_RES_OK</span><span class="p">)</span> <span class="n">error</span><span class="p">(</span><span class="s">&quot;Couldn&#39;t create obj pool&quot;</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">res</span> <span class="o">!=</span> <span class="n">MPS_RES_OK</span><span class="p">)</span> <span class="n">error</span><span class="p">(</span><span class="s">&quot;Couldn&#39;t create obj format&quot;</span><span class="p">);</span>
</pre></div>
</div>
<dl class="type">
<dt id="mps_fmt_A_s">
<tt class="descname">mps_fmt_A_s</tt><a class="headerlink" href="#mps_fmt_A_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant A.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_A_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_skip_t</span> <span class="n">skip</span><span class="p">;</span>
<span class="kt">mps_fmt_copy_t</span> <span class="n">copy</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_A_s</span><span class="p">;</span>
</pre></div>
</div>
<p>Broadly speaking, object formats of variant A are suitable for use
in <a class="reference internal" href="../glossary/c.html#term-copying-garbage-collection"><em class="xref std std-term">copying</em></a> or <a class="reference internal" href="../glossary/m.html#term-moving-garbage-collector"><em class="xref std std-term">moving</em></a> <a class="reference internal" href="../glossary/p.html#term-pool"><em class="xref std std-term">pools</em></a>.</p>
<p><tt class="docutils literal"><span class="pre">align</span></tt> is an integer value specifying the alignment of objects
allocated with this format. It should be large enough to satisfy
the alignment requirements of any field in the objects, and it
must not be larger than the pool alignment.</p>
<p><tt class="docutils literal"><span class="pre">scan</span></tt> is a <a class="reference internal" href="../glossary/s.html#term-scan-method"><em class="xref std std-term">scan method</em></a> that identifies references
within objects belonging to this format. See
<a class="reference internal" href="#mps_fmt_scan_t" title="mps_fmt_scan_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_scan_t</span></tt></a>.</p>
<p><tt class="docutils literal"><span class="pre">skip</span></tt> is a <a class="reference internal" href="../glossary/s.html#term-skip-method"><em class="xref std std-term">skip method</em></a> that skips over objects
belonging to this format. See <a class="reference internal" href="#mps_fmt_skip_t" title="mps_fmt_skip_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_skip_t</span></tt></a>.</p>
<p><tt class="docutils literal"><span class="pre">copy</span></tt> is not used. (In older versions of the MPS it was a
<a class="reference internal" href="../glossary/c.html#term-copy-method"><em class="xref std std-term">copy method</em></a> that copied objects belonging to this
format.)</p>
<p><tt class="docutils literal"><span class="pre">fwd</span></tt> is a <a class="reference internal" href="../glossary/f.html#term-forward-method"><em class="xref std std-term">forward method</em></a> that stores relocation
information for an object belonging to this format that has moved.
See <a class="reference internal" href="#mps_fmt_fwd_t" title="mps_fmt_fwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_fwd_t</span></tt></a>.</p>
<p><tt class="docutils literal"><span class="pre">isfwd</span></tt> is a <a class="reference internal" href="../glossary/i.html#term-is-forwarded-method"><em class="xref std std-term">is-forwarded method</em></a> that determines if an
object belonging to this format has been moved. See
<a class="reference internal" href="#mps_fmt_isfwd_t" title="mps_fmt_isfwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_isfwd_t</span></tt></a>.</p>
<p><tt class="docutils literal"><span class="pre">pad</span></tt> is a <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a> that creates <a class="reference internal" href="../glossary/p.html#term-padding-object"><em class="xref std std-term">padding
objects</em></a> belonging to this format. See <a class="reference internal" href="#mps_fmt_pad_t" title="mps_fmt_pad_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_pad_t</span></tt></a>.</p>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_A">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_A</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s">mps_fmt_A_s</a><em>&nbsp;*fmt_A</em><big>)</big><a class="headerlink" href="#mps_fmt_create_A" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> of variant A.</p>
<p><tt class="docutils literal"><span class="pre">fmt_o</span></tt> points to a location that will hold the address of the new
object format.</p>
<p><tt class="docutils literal"><span class="pre">arena</span></tt> is the arena in which to create the format.</p>
<p><tt class="docutils literal"><span class="pre">fmt_A</span></tt> points to a description of an object format of variant A.</p>
<p>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> if successful. The MPS may exhaust
some resource in the course of <a class="reference internal" href="#mps_fmt_create_A" title="mps_fmt_create_A"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_A()</span></tt></a> and will
return an appropriate <a class="reference internal" href="../glossary/r.html#term-result-code"><em class="xref std std-term">result code</em></a> if so.</p>
<p>After this function returns, the object format description pointed
to be <tt class="docutils literal"><span class="pre">fmt_A</span></tt> is no longer needed and may be discarded. The object
format pointed to by <tt class="docutils literal"><span class="pre">fmt_o</span></tt> persists until it is destroyed by
calling <a class="reference internal" href="#mps_fmt_destroy" title="mps_fmt_destroy"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_destroy()</span></tt></a>.</p>
</dd></dl>
<dl class="type">
<dt id="mps_fmt_B_s">
<tt class="descname">mps_fmt_B_s</tt><a class="headerlink" href="#mps_fmt_B_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant B.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_B_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_skip_t</span> <span class="n">skip</span><span class="p">;</span>
<span class="kt">mps_fmt_copy_t</span> <span class="n">copy</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="kt">mps_fmt_class_t</span> <span class="n">mps_class</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_B_s</span><span class="p">;</span>
</pre></div>
</div>
<p>Variant B is the same as variant A except for the addition of the
<tt class="docutils literal"><span class="pre">mps_class</span></tt> method. See <a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>.</p>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_B">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_B</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_B_s" title="mps_fmt_B_s">mps_fmt_B_s</a><em>&nbsp;*fmt_B</em><big>)</big><a class="headerlink" href="#mps_fmt_create_B" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> of variant B.</p>
<p><tt class="docutils literal"><span class="pre">fmt_o</span></tt> points to a location that will hold the address of the new
object format.</p>
<p><tt class="docutils literal"><span class="pre">arena</span></tt> is the arena in which to create the format.</p>
<p><tt class="docutils literal"><span class="pre">fmt_B</span></tt> points to a description of an object format of variant B.</p>
<p>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> if successful. The MPS may exhaust
some resource in the course of <a class="reference internal" href="#mps_fmt_create_B" title="mps_fmt_create_B"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_B()</span></tt></a> and will
return an appropriate <a class="reference internal" href="../glossary/r.html#term-result-code"><em class="xref std std-term">result code</em></a> if so.</p>
</dd></dl>
<dl class="type">
<dt id="mps_fmt_auto_header_s">
<tt class="descname">mps_fmt_auto_header_s</tt><a class="headerlink" href="#mps_fmt_auto_header_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant auto-header.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_auto_header_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_skip_t</span> <span class="n">skip</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="kt">size_t</span> <span class="n">mps_headerSize</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_auto_header_s</span><span class="p">;</span>
</pre></div>
</div>
<p>Variant auto-header is the same as variant A except for the
removal of the unused <tt class="docutils literal"><span class="pre">copy</span></tt> method, and the addition of the
<tt class="docutils literal"><span class="pre">mps_headerSize</span></tt> field. See <a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>.</p>
<p>Broadly speaking, the object formats of this variant are suitable
for use in <a class="reference internal" href="../glossary/a.html#term-automatic-memory-management"><em class="xref std std-term">automatic memory management</em></a> for objects with
<a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">headers</em></a> (hence the name). More precisely,
this variant is intended for formats where the <a class="reference internal" href="../glossary/c.html#term-client-program"><em class="xref std std-term">client
program&#8217;s</em></a> pointers point some distance into the
memory <a class="reference internal" href="../glossary/b.html#term-block"><em class="xref std std-term">block</em></a> containing the object. This typically happens
when the objects have a common header used for memory management
or class system purposes, but this situation also arises when the
low bits of a pointer are used for a tag. The MPS does not care
what the reason is, only about the offset of the pointer in
relation to the memory block.</p>
<p><tt class="docutils literal"><span class="pre">mps_headerSize</span></tt> is the size of the header, that is, the offset of
a client pointer from the base of the memory block.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p>Format methods (other than the <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a>) for
formats of this variant will receive <em>client pointers</em> (that
is, pointers past the header) but all other MPS functions
expect to receive and return <em>base pointers</em> (that is,
pointers to the base of the block where the header is stored).</p>
<p class="last">In particular, <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> and <a class="reference internal" href="allocation.html#mps_alloc" title="mps_alloc"><tt class="xref c c-func docutils literal"><span class="pre">mps_alloc()</span></tt></a>
always hand out base pointers, and <a class="reference internal" href="allocation.html#mps_free" title="mps_free"><tt class="xref c c-func docutils literal"><span class="pre">mps_free()</span></tt></a> expects
to receive one.</p>
</div>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">For technical reasons, formatted objects must be longer than
the header. In other words, objects consisting of only a
header are not supported.</p>
</div>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">Even if the header size is larger than or equal to
<a class="reference internal" href="../glossary/a.html#term-alignment"><em class="xref std std-term">alignment</em></a>, the <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a> must still be
able to create <a class="reference internal" href="../glossary/p.html#term-padding-object"><em class="xref std std-term">padding objects</em></a> down
to the alignment size.</p>
</div>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_auto_header">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_auto_header</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_auto_header_s" title="mps_fmt_auto_header_s">mps_fmt_auto_header_s</a><em>&nbsp;*fmt_ah</em><big>)</big><a class="headerlink" href="#mps_fmt_create_auto_header" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> of variant auto-header.</p>
<p><tt class="docutils literal"><span class="pre">fmt_o</span></tt> points to a location that will hold the address of the new
object format.</p>
<p><tt class="docutils literal"><span class="pre">arena</span></tt> is the arena in which to create the format.</p>
<p><tt class="docutils literal"><span class="pre">fmt_ah</span></tt> points to a description of an object format of variant
auto-header.</p>
<p>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> if successful. The MPS may exhaust
some resource in the course of
<a class="reference internal" href="#mps_fmt_create_auto_header" title="mps_fmt_create_auto_header"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_auto_header()</span></tt></a> and will return an
appropriate <a class="reference internal" href="../glossary/r.html#term-result-code"><em class="xref std std-term">result code</em></a> if so.</p>
</dd></dl>
<dl class="function">
@ -303,9 +158,45 @@ <h3>Navigation</h3>
<a class="reference internal" href="../glossary/p.html#term-pool"><em class="xref std std-term">pool</em></a> using the format. The pool must be destroyed first.</p>
</dd></dl>
</div>
<div class="section" id="in-band-headers">
<span id="topic-format-headers"></span><span id="index-2"></span><h2>7.2. In-band headers<a class="headerlink" href="#in-band-headers" title="Permalink to this headline"></a></h2>
<p>There are use cases in which it is convenient for the <a class="reference internal" href="../glossary/c.html#term-client-program"><em class="xref std std-term">client
program&#8217;s</em></a> pointers to point some distance into the
memory <a class="reference internal" href="../glossary/b.html#term-block"><em class="xref std std-term">block</em></a> containing the object. This typically happens
when the objects have a common <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band header</em></a> used for memory
management or class system purposes, but this situation also arises
when the low bits of a pointer are used for a tag. The MPS does not
care what the reason is, only about the offset of the pointer in
relation to the memory block.</p>
<p>If you have one of these use cases, you should pass the
<tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_HEADER_SIZE</span></tt> <a class="reference internal" href="../glossary/k.html#term-keyword-argument"><em class="xref std std-term">keyword argument</em></a> to
<a class="reference internal" href="#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a>, specifying the size of the header: that
is, the offset of a client pointer from the base of the memory block.</p>
<p>There are some cautions to be observed when using in-band headers:</p>
<ol class="arabic">
<li><p class="first">The format methods (other than the <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a>) receive
<em>client pointers</em> (that is, pointers past the header) but all other
MPS functions expect to receive and return <em>base pointers</em> (that
is, pointers to the base of the block where the header is stored).</p>
<p>In particular, <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> and <a class="reference internal" href="allocation.html#mps_alloc" title="mps_alloc"><tt class="xref c c-func docutils literal"><span class="pre">mps_alloc()</span></tt></a> always
hand out base pointers, and <a class="reference internal" href="allocation.html#mps_free" title="mps_free"><tt class="xref c c-func docutils literal"><span class="pre">mps_free()</span></tt></a> expects to receive
one.</p>
</li>
<li><p class="first">Formatted objects must be longer than the header. In other words,
objects consisting of only a header are not supported.</p>
</li>
<li><p class="first">Even if the header size is larger than or equal to
<a class="reference internal" href="../glossary/a.html#term-alignment"><em class="xref std std-term">alignment</em></a>, the <a class="reference internal" href="../glossary/p.html#term-padding-method"><em class="xref std std-term">padding method</em></a> must still be able to
create <a class="reference internal" href="../glossary/p.html#term-padding-object"><em class="xref std std-term">padding objects</em></a> down to the alignment size.</p>
</li>
<li><p class="first">Not all <a class="reference internal" href="../glossary/p.html#term-pool-class"><em class="xref std std-term">pool classes</em></a> support objects with in-band headers.
See the documentation for the pool class.</p>
</li>
</ol>
</div>
<div class="section" id="cautions">
<span id="topic-format-cautions"></span><span id="index-2"></span><h2>7.2. Cautions<a class="headerlink" href="#cautions" title="Permalink to this headline"></a></h2>
<span id="topic-format-cautions"></span><span id="index-3"></span><h2>7.3. Cautions<a class="headerlink" href="#cautions" title="Permalink to this headline"></a></h2>
<ol class="arabic">
<li><p class="first">The MPS guarantees that format methods have exclusive access to the
object for the duration of the call. This guarantee may entail
@ -357,7 +248,7 @@ <h3>Navigation</h3>
</ol>
</div>
<div class="section" id="format-methods">
<span id="index-3"></span><h2>7.3. Format methods<a class="headerlink" href="#format-methods" title="Permalink to this headline"></a></h2>
<span id="index-4"></span><h2>7.4. Format methods<a class="headerlink" href="#format-methods" title="Permalink to this headline"></a></h2>
<dl class="type">
<dt id="mps_fmt_class_t">
<a class="reference internal" href="interface.html#mps_addr_t" title="mps_addr_t">mps_addr_t</a> <tt class="descname">(*mps_fmt_class_t)</tt><big>(</big><a class="reference internal" href="interface.html#mps_addr_t" title="mps_addr_t">mps_addr_t</a><em>&nbsp;addr</em><big>)</big><a class="headerlink" href="#mps_fmt_class_t" title="Permalink to this definition"></a></dt>
@ -436,7 +327,8 @@ <h3>Navigation</h3>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">The padding method always receives a base pointer, even if the
object format belongs to variant auto-header.</p>
object format has a non-zero
<tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_HEADER_SIZE</span></tt>.</p>
</div>
</dd></dl>
@ -480,9 +372,8 @@ <h3>Navigation</h3>
<p>Returns the address of the &#8220;next object&#8221;. In an object format
without headers (for example, a format of variant A), this is the
address just past the end of this object. In an object format with
headers (for example, a format of variant auto-header), it&#8217;s the
address just past where the header of next object would be, if
there were one.</p>
<a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>, it&#8217;s the address just past where the
header of next object would be, if there were one.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">In either case, the result is the sum of <tt class="docutils literal"><span class="pre">addr</span></tt> and the size
@ -499,7 +390,7 @@ <h3>Navigation</h3>
</div>
<div class="section" id="object-format-introspection">
<span id="index-4"></span><h2>7.4. Object format introspection<a class="headerlink" href="#object-format-introspection" title="Permalink to this headline"></a></h2>
<span id="index-5"></span><h2>7.5. Object format introspection<a class="headerlink" href="#object-format-introspection" title="Permalink to this headline"></a></h2>
<dl class="function">
<dt id="mps_addr_fmt">
<a class="reference internal" href="interface.html#mps_bool_t" title="mps_bool_t">mps_bool_t</a> <tt class="descname">mps_addr_fmt</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="interface.html#mps_addr_t" title="mps_addr_t">mps_addr_t</a><em>&nbsp;addr</em><big>)</big><a class="headerlink" href="#mps_addr_fmt" title="Permalink to this definition"></a></dt>
@ -588,6 +479,143 @@ <h3>Navigation</h3>
</div>
</dd></dl>
</div>
<div class="section" id="obsolete-interface">
<h2>7.6. Obsolete interface<a class="headerlink" href="#obsolete-interface" title="Permalink to this headline"></a></h2>
<div class="admonition-deprecated admonition">
<p class="first admonition-title">Deprecated</p>
<p>starting with version 1.112.</p>
<p class="last">Use <a class="reference internal" href="allocation.html#mps_ap_create_k" title="mps_ap_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_ap_create_k()</span></tt></a> instead: the <a class="reference internal" href="../glossary/k.html#term-keyword-argument"><em class="xref std std-term">keyword
arguments</em></a> interface is more flexible and easier to understand.</p>
</div>
<p>Formerly the only way to create object formats was to describe the
format in the form of a <em>format variant structure</em>.</p>
<p>There are four format variants.</p>
<ul class="simple">
<li>Variant A (<a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>): for objects without
<a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">headers</em></a>.</li>
<li>Variant B (<a class="reference internal" href="#mps_fmt_B_s" title="mps_fmt_B_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_B_s</span></tt></a>): as variant A, but with the
addition of a class method.</li>
<li>Variant auto-header (<a class="reference internal" href="#mps_fmt_auto_header_s" title="mps_fmt_auto_header_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_auto_header_s</span></tt></a>): for objects
with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>.</li>
<li>Variant fixed (<a class="reference internal" href="#mps_fmt_fixed_s" title="mps_fmt_fixed_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_fixed_s</span></tt></a>): for fixed-size objects.</li>
</ul>
<p>The client program creates an object format by construct a format
variant structure and then calling the appropriate <tt class="docutils literal"><span class="pre">mps_fmt_create_</span></tt>
function for the variant. The variant structure can then be disposed
of.</p>
<dl class="type">
<dt id="mps_fmt_A_s">
<tt class="descname">mps_fmt_A_s</tt><a class="headerlink" href="#mps_fmt_A_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant A.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_A_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_skip_t</span> <span class="n">skip</span><span class="p">;</span>
<span class="kt">mps_fmt_copy_t</span> <span class="n">copy</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_A_s</span><span class="p">;</span>
</pre></div>
</div>
<p>The fields of this structure correspond to the keyword arguments
to <a class="reference internal" href="#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a>, except for <tt class="docutils literal"><span class="pre">copy</span></tt>, which is not
used. In older versions of the MPS this was a <a class="reference internal" href="../glossary/c.html#term-copy-method"><em class="xref std std-term">copy method</em></a>
that copied objects belonging to this format.</p>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_A">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_A</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s">mps_fmt_A_s</a><em>&nbsp;*fmt_A</em><big>)</big><a class="headerlink" href="#mps_fmt_create_A" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> based on a description of an
object format of variant A.</p>
</dd></dl>
<dl class="type">
<dt id="mps_fmt_B_s">
<tt class="descname">mps_fmt_B_s</tt><a class="headerlink" href="#mps_fmt_B_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant B.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_B_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_skip_t</span> <span class="n">skip</span><span class="p">;</span>
<span class="kt">mps_fmt_copy_t</span> <span class="n">copy</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="kt">mps_fmt_class_t</span> <span class="n">mps_class</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_B_s</span><span class="p">;</span>
</pre></div>
</div>
<p>Variant B is the same as variant A except for the addition of the
<tt class="docutils literal"><span class="pre">mps_class</span></tt> method. See <a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>.</p>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_B">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_B</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_B_s" title="mps_fmt_B_s">mps_fmt_B_s</a><em>&nbsp;*fmt_B</em><big>)</big><a class="headerlink" href="#mps_fmt_create_B" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> based on a description of an
object format of variant B.</p>
</dd></dl>
<dl class="type">
<dt id="mps_fmt_auto_header_s">
<tt class="descname">mps_fmt_auto_header_s</tt><a class="headerlink" href="#mps_fmt_auto_header_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant auto-header.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_auto_header_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_skip_t</span> <span class="n">skip</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="kt">size_t</span> <span class="n">mps_headerSize</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_auto_header_s</span><span class="p">;</span>
</pre></div>
</div>
<p>Variant auto-header is the same as variant A except for the
removal of the unused <tt class="docutils literal"><span class="pre">copy</span></tt> method, and the addition of the
<tt class="docutils literal"><span class="pre">mps_headerSize</span></tt> field. See <a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>.</p>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_auto_header">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_auto_header</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_auto_header_s" title="mps_fmt_auto_header_s">mps_fmt_auto_header_s</a><em>&nbsp;*fmt_ah</em><big>)</big><a class="headerlink" href="#mps_fmt_create_auto_header" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> based on a description of an
object format of variant auto-header.</p>
</dd></dl>
<dl class="type">
<dt id="mps_fmt_fixed_s">
<tt class="descname">mps_fmt_fixed_s</tt><a class="headerlink" href="#mps_fmt_fixed_s" title="Permalink to this definition"></a></dt>
<dd><p>The type of the structure used to create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a>
of variant fixed.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_fmt_fixed_s</span> <span class="p">{</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_fmt_scan_t</span> <span class="n">scan</span><span class="p">;</span>
<span class="kt">mps_fmt_fwd_t</span> <span class="n">fwd</span><span class="p">;</span>
<span class="kt">mps_fmt_isfwd_t</span> <span class="n">isfwd</span><span class="p">;</span>
<span class="kt">mps_fmt_pad_t</span> <span class="n">pad</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_fmt_fixed_s</span><span class="p">;</span>
</pre></div>
</div>
<p>Variant fixed is the same as variant A except for the removal of
the unused <tt class="docutils literal"><span class="pre">copy</span></tt> method, and the lack of a <tt class="docutils literal"><span class="pre">skip</span></tt> method
(this is not needed because the objects are fixed in size). See
<a class="reference internal" href="#mps_fmt_A_s" title="mps_fmt_A_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_A_s</span></tt></a>.</p>
</dd></dl>
<dl class="function">
<dt id="mps_fmt_create_fixed">
<a class="reference internal" href="error.html#mps_res_t" title="mps_res_t">mps_res_t</a> <tt class="descname">mps_fmt_create_fixed</tt><big>(</big><a class="reference internal" href="#mps_fmt_t" title="mps_fmt_t">mps_fmt_t</a><em>&nbsp;*fmt_o</em>, <a class="reference internal" href="arena.html#mps_arena_t" title="mps_arena_t">mps_arena_t</a><em>&nbsp;arena</em>, <a class="reference internal" href="#mps_fmt_fixed_s" title="mps_fmt_fixed_s">mps_fmt_fixed_s</a><em>&nbsp;*fmt_fixed</em><big>)</big><a class="headerlink" href="#mps_fmt_create_fixed" title="Permalink to this definition"></a></dt>
<dd><p>Create an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> based on a description of an
object format of variant fixed.</p>
</dd></dl>
</div>
</div>
@ -603,10 +631,12 @@ <h3>Navigation</h3>
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">7. Object formats</a><ul>
<li><a class="reference internal" href="#creating-an-object-format">7.1. Creating an object format</a></li>
<li><a class="reference internal" href="#cautions">7.2. Cautions</a></li>
<li><a class="reference internal" href="#format-methods">7.3. Format methods</a></li>
<li><a class="reference internal" href="#object-format-introspection">7.4. Object format introspection</a></li>
<li><a class="reference internal" href="#interface">7.1. Interface</a></li>
<li><a class="reference internal" href="#in-band-headers">7.2. In-band headers</a></li>
<li><a class="reference internal" href="#cautions">7.3. Cautions</a></li>
<li><a class="reference internal" href="#format-methods">7.4. Format methods</a></li>
<li><a class="reference internal" href="#object-format-introspection">7.5. Object format introspection</a></li>
<li><a class="reference internal" href="#obsolete-interface">7.6. Obsolete interface</a></li>
</ul>
</li>
</ul>

10
mps/manual/html/topic/index.html
View file

@ -106,10 +106,12 @@ <h3>Navigation</h3>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="format.html">7. Object formats</a><ul>
<li class="toctree-l2"><a class="reference internal" href="format.html#creating-an-object-format">7.1. Creating an object format</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#cautions">7.2. Cautions</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#format-methods">7.3. Format methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#object-format-introspection">7.4. Object format introspection</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#interface">7.1. Interface</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#in-band-headers">7.2. In-band headers</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#cautions">7.3. Cautions</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#format-methods">7.4. Format methods</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#object-format-introspection">7.5. Object format introspection</a></li>
<li class="toctree-l2"><a class="reference internal" href="format.html#obsolete-interface">7.6. Obsolete interface</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="scanning.html">8. Scanning</a><ul>

116
mps/manual/html/topic/keyword.html
View file

@ -100,38 +100,20 @@ <h3>Navigation</h3>
<a class="reference internal" href="../glossary/k.html#term-keyword-argument"><em class="xref std std-term">keyword argument</em></a> to a function.</p>
<div class="highlight-c"><div class="highlight"><pre><span class="k">typedef</span> <span class="k">struct</span> <span class="n">mps_arg_s</span> <span class="p">{</span>
<span class="kt">mps_key_t</span> <span class="n">key</span><span class="p">;</span>
<span class="k">union</span> <span class="p">{</span>
<span class="kt">mps_bool_t</span> <span class="n">b</span><span class="p">;</span>
<span class="kt">char</span> <span class="n">c</span><span class="p">;</span>
<span class="k">const</span> <span class="kt">char</span> <span class="o">*</span><span class="n">string</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">i</span><span class="p">;</span>
<span class="kt">unsigned</span> <span class="n">u</span><span class="p">;</span>
<span class="kt">long</span> <span class="n">l</span><span class="p">;</span>
<span class="kt">unsigned</span> <span class="kt">long</span> <span class="n">ul</span><span class="p">;</span>
<span class="kt">size_t</span> <span class="n">size</span><span class="p">;</span>
<span class="kt">mps_addr_t</span> <span class="n">addr</span><span class="p">;</span>
<span class="kt">mps_fmt_t</span> <span class="n">format</span><span class="p">;</span>
<span class="kt">mps_chain_t</span> <span class="n">chain</span><span class="p">;</span>
<span class="k">struct</span> <span class="n">mps_pool_debug_option_s</span> <span class="o">*</span><span class="n">pool_debug_options</span><span class="p">;</span>
<span class="kt">mps_addr_t</span> <span class="p">(</span><span class="o">*</span><span class="n">addr_method</span><span class="p">)(</span><span class="kt">mps_addr_t</span><span class="p">);</span>
<span class="kt">mps_align_t</span> <span class="n">align</span><span class="p">;</span>
<span class="kt">mps_word_t</span> <span class="n">count</span><span class="p">;</span>
<span class="kt">void</span> <span class="o">*</span><span class="n">p</span><span class="p">;</span>
<span class="kt">mps_rank_t</span> <span class="n">rank</span><span class="p">;</span>
<span class="p">}</span> <span class="n">val</span><span class="p">;</span>
<span class="k">union</span> <span class="p">{</span> <span class="cm">/* many fields; see table below */</span> <span class="p">}</span> <span class="n">val</span><span class="p">;</span>
<span class="p">}</span> <span class="n">mps_arg_s</span><span class="p">;</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">key</span></tt> identifies the key. It must be one of the legal values
of <a class="reference internal" href="#mps_key_t" title="mps_key_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_key_t</span></tt></a> listed in the documentation for that type.</p>
<p><tt class="docutils literal"><span class="pre">val</span></tt> is the corresponding value. The table given in the
documentation for <a class="reference internal" href="#mps_key_t" title="mps_key_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_key_t</span></tt></a> explains which structure
field is used by that keyword.</p>
<p><tt class="docutils literal"><span class="pre">key</span></tt> identifies the key. It must be one of the values listed in
the documentation for the type <a class="reference internal" href="#mps_key_t" title="mps_key_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_key_t</span></tt></a>.</p>
<p><tt class="docutils literal"><span class="pre">val</span></tt> is the corresponding value. This union contains many
fields: one for each keyword argument type. The table given in the
documentation for <a class="reference internal" href="#mps_key_t" title="mps_key_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_key_t</span></tt></a> below indicates which
structure field is used by each keyword.</p>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>
<p class="last">If you use the convenience macros <a class="reference internal" href="#MPS_ARGS_ADD" title="MPS_ARGS_ADD"><tt class="xref c c-func docutils literal"><span class="pre">MPS_ARGS_ADD()</span></tt></a> and
<tt class="xref c c-func docutils literal"><span class="pre">MPS_ARG()</span></tt> you don&#8217;t need to know the name of the
field.</p>
<p class="last">If you use the convenience macro <a class="reference internal" href="#MPS_ARGS_ADD" title="MPS_ARGS_ADD"><tt class="xref c c-func docutils literal"><span class="pre">MPS_ARGS_ADD()</span></tt></a> then
you don&#8217;t need to know the name of the field.</p>
</div>
</dd></dl>
@ -152,13 +134,13 @@ <h3>Navigation</h3>
following values:</p>
<table border="1" class="docutils">
<colgroup>
<col width="19%" />
<col width="10%" />
<col width="71%" />
<col width="16%" />
<col width="22%" />
<col width="61%" />
</colgroup>
<thead valign="bottom">
<tr class="row-odd"><th class="head">Keyword</th>
<th class="head">Field</th>
<th class="head">Type &amp; field in <tt class="docutils literal"><span class="pre">arg.val</span></tt></th>
<th class="head">See</th>
</tr>
</thead>
@ -168,83 +150,115 @@ <h3>Navigation</h3>
<td><em>see above</em></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_ALIGN</span></tt></td>
<td><tt class="docutils literal"><span class="pre">align</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_align_t" title="mps_align_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_align_t</span></tt></a> <tt class="docutils literal"><span class="pre">align</span></tt></td>
<td><a class="reference internal" href="../pool/mvff.html#mps_class_mvff" title="mps_class_mvff"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_AMS_SUPPORT_AMBIGUOUS</span></tt></td>
<td><tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_bool_t" title="mps_bool_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_bool_t</span></tt></a> <tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="../pool/ams.html#mps_class_ams" title="mps_class_ams"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_ams()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_ARENA_CL_BASE</span></tt></td>
<td><tt class="docutils literal"><span class="pre">addr</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_addr_t" title="mps_addr_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_addr_t</span></tt></a> <tt class="docutils literal"><span class="pre">addr</span></tt></td>
<td><a class="reference internal" href="arena.html#mps_arena_class_cl" title="mps_arena_class_cl"><tt class="xref c c-func docutils literal"><span class="pre">mps_arena_class_cl()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_ARENA_SIZE</span></tt></td>
<td><tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="arena.html#mps_arena_class_vm" title="mps_arena_class_vm"><tt class="xref c c-func docutils literal"><span class="pre">mps_arena_class_vm()</span></tt></a>, <a class="reference internal" href="arena.html#mps_arena_class_cl" title="mps_arena_class_cl"><tt class="xref c c-func docutils literal"><span class="pre">mps_arena_class_cl()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_AWL_FIND_DEPENDENT</span></tt></td>
<td><tt class="docutils literal"><span class="pre">addr_method</span></tt></td>
<td><tt class="docutils literal"><span class="pre">void</span> <span class="pre">*(*)(void</span> <span class="pre">*)</span></tt> <tt class="docutils literal"><span class="pre">addr_method</span></tt></td>
<td><a class="reference internal" href="../pool/awl.html#mps_class_awl" title="mps_class_awl"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_awl()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_CHAIN</span></tt></td>
<td><tt class="docutils literal"><span class="pre">chain</span></tt></td>
<td><a class="reference internal" href="collection.html#mps_chain_t" title="mps_chain_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_chain_t</span></tt></a> <tt class="docutils literal"><span class="pre">chain</span></tt></td>
<td><a class="reference internal" href="../pool/amc.html#mps_class_amc" title="mps_class_amc"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_amc()</span></tt></a>, <a class="reference internal" href="../pool/amcz.html#mps_class_amcz" title="mps_class_amcz"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_amcz()</span></tt></a>, <a class="reference internal" href="../pool/ams.html#mps_class_ams" title="mps_class_ams"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_ams()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_EXTEND_BY</span></tt></td>
<td><tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="../pool/mfs.html#mps_class_mfs" title="mps_class_mfs"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mfs()</span></tt></a>, <a class="reference internal" href="../pool/mv.html#mps_class_mv" title="mps_class_mv"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mv()</span></tt></a>, <a class="reference internal" href="../pool/mvff.html#mps_class_mvff" title="mps_class_mvff"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_ALIGN</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_align_t" title="mps_align_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_align_t</span></tt></a> <tt class="docutils literal"><span class="pre">align</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_CLASS</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_class_t" title="mps_fmt_class_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_class_t</span></tt></a> <tt class="docutils literal"><span class="pre">fmt_class</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_FWD</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_fwd_t" title="mps_fmt_fwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_fwd_t</span></tt></a> <tt class="docutils literal"><span class="pre">fmt_fwd</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_HEADER_SIZE</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_ISFWD</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_isfwd_t" title="mps_fmt_isfwd_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_isfwd_t</span></tt></a> <tt class="docutils literal"><span class="pre">fmt_isfwd</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_PAD</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_pad_t" title="mps_fmt_pad_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_pad_t</span></tt></a> <tt class="docutils literal"><span class="pre">fmt_pad</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_SCAN</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_scan_t" title="mps_fmt_scan_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_scan_t</span></tt></a> <tt class="docutils literal"><span class="pre">fmt_scan</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FMT_SKIP</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_skip_t" title="mps_fmt_skip_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_skip_t</span></tt></a> <tt class="docutils literal"><span class="pre">fmt_skip</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_create_k" title="mps_fmt_create_k"><tt class="xref c c-func docutils literal"><span class="pre">mps_fmt_create_k()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_FORMAT</span></tt></td>
<td><tt class="docutils literal"><span class="pre">format</span></tt></td>
<td><a class="reference internal" href="format.html#mps_fmt_t" title="mps_fmt_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_t</span></tt></a> <tt class="docutils literal"><span class="pre">format</span></tt></td>
<td><a class="reference internal" href="../pool/amc.html#mps_class_amc" title="mps_class_amc"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_amc()</span></tt></a>, <a class="reference internal" href="../pool/amcz.html#mps_class_amcz" title="mps_class_amcz"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_amcz()</span></tt></a>, <a class="reference internal" href="../pool/ams.html#mps_class_ams" title="mps_class_ams"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_ams()</span></tt></a>, <a class="reference internal" href="../pool/awl.html#mps_class_awl" title="mps_class_awl"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_awl()</span></tt></a>, <a class="reference internal" href="../pool/lo.html#mps_class_lo" title="mps_class_lo"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_lo()</span></tt></a> , <a class="reference internal" href="../pool/snc.html#mps_class_snc" title="mps_class_snc"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_snc()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MAX_SIZE</span></tt></td>
<td><tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="../pool/mv.html#mps_class_mv" title="mps_class_mv"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mv()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MEAN_SIZE</span></tt></td>
<td><tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="../pool/mv.html#mps_class_mv" title="mps_class_mv"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mv()</span></tt></a>, <a class="reference internal" href="../pool/mvt.html#mps_class_mvt" title="mps_class_mvt"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvt()</span></tt></a>, <a class="reference internal" href="../pool/mvff.html#mps_class_mvff" title="mps_class_mvff"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MFS_UNIT_SIZE</span></tt></td>
<td><tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="../pool/mfs.html#mps_class_mfs" title="mps_class_mfs"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mfs()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MIN_SIZE</span></tt></td>
<td><tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">size_t</span></tt> <tt class="docutils literal"><span class="pre">size</span></tt></td>
<td><a class="reference internal" href="../pool/mvt.html#mps_class_mvt" title="mps_class_mvt"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvt()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MVFF_ARENA_HIGH</span></tt></td>
<td><tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_bool_t" title="mps_bool_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_bool_t</span></tt></a> <tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="../pool/mvff.html#mps_class_mvff" title="mps_class_mvff"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MVFF_FIRST_FIT</span></tt></td>
<td><tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_bool_t" title="mps_bool_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_bool_t</span></tt></a> <tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="../pool/mvff.html#mps_class_mvff" title="mps_class_mvff"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MVFF_SLOT_HIGH</span></tt></td>
<td><tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_bool_t" title="mps_bool_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_bool_t</span></tt></a> <tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="../pool/mvff.html#mps_class_mvff" title="mps_class_mvff"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MVT_FRAG_LIMIT</span></tt></td>
<td><tt class="docutils literal"><span class="pre">count</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">mps_count_t</span></tt> <tt class="docutils literal"><span class="pre">count</span></tt></td>
<td><a class="reference internal" href="../pool/mvt.html#mps_class_mvt" title="mps_class_mvt"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvt()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_MVT_RESERVE_DEPTH</span></tt></td>
<td><tt class="docutils literal"><span class="pre">count</span></tt></td>
<td><tt class="xref c c-type docutils literal"><span class="pre">mps_count_t</span></tt> <tt class="docutils literal"><span class="pre">count</span></tt></td>
<td><a class="reference internal" href="../pool/mvt.html#mps_class_mvt" title="mps_class_mvt"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvt()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_POOL_DEBUG_OPTIONS</span></tt></td>
<td><tt class="docutils literal"><span class="pre">pool_debug_options</span></tt></td>
<td><tt class="docutils literal"><span class="pre">mps_pool_debug_options_s&nbsp;*</span></tt> <tt class="docutils literal"><span class="pre">pool_debug_options</span></tt></td>
<td><a class="reference internal" href="../pool/ams.html#mps_class_ams_debug" title="mps_class_ams_debug"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_ams_debug()</span></tt></a>, <a class="reference internal" href="../pool/mv.html#mps_class_mv_debug" title="mps_class_mv_debug"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mv_debug()</span></tt></a>, <a class="reference internal" href="../pool/mvff.html#mps_class_mvff_debug" title="mps_class_mvff_debug"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_mvff_debug()</span></tt></a></td>
</tr>
<tr class="row-odd"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_RANK</span></tt></td>
<td><tt class="docutils literal"><span class="pre">rank</span></tt></td>
<td><a class="reference internal" href="root.html#mps_rank_t" title="mps_rank_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_rank_t</span></tt></a> <tt class="docutils literal"><span class="pre">rank</span></tt></td>
<td><a class="reference internal" href="../pool/awl.html#mps_class_awl" title="mps_class_awl"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_awl()</span></tt></a>, <a class="reference internal" href="../pool/snc.html#mps_class_snc" title="mps_class_snc"><tt class="xref c c-func docutils literal"><span class="pre">mps_class_snc()</span></tt></a></td>
</tr>
<tr class="row-even"><td><tt class="xref c c-macro docutils literal"><span class="pre">MPS_KEY_VMW3_TOP_DOWN</span></tt></td>
<td><tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="interface.html#mps_bool_t" title="mps_bool_t"><tt class="xref c c-type docutils literal"><span class="pre">mps_bool_t</span></tt></a> <tt class="docutils literal"><span class="pre">b</span></tt></td>
<td><a class="reference internal" href="arena.html#mps_arena_class_vm" title="mps_arena_class_vm"><tt class="xref c c-func docutils literal"><span class="pre">mps_arena_class_vm()</span></tt></a></td>
</tr>
</tbody>

20
mps/manual/html/topic/pool.html
View file

@ -126,6 +126,26 @@ <h3>Navigation</h3>
<p>It is an error to destroy a pool without first destroying all
<a class="reference internal" href="../glossary/a.html#term-allocation-point"><em class="xref std std-term">allocation points</em></a> and <a class="reference internal" href="../glossary/s.html#term-segregated-allocation-cache"><em class="xref std std-term">segregated allocation caches</em></a>
created in the pool.</p>
<div class="admonition warning">
<p class="first admonition-title">Warning</p>
<p>It is not safe to destroy an <a class="reference internal" href="../glossary/a.html#term-automatic-memory-management"><em class="xref std std-term">automatically managed</em></a> pool if it contains any objects
that are <a class="reference internal" href="../glossary/r.html#term-reachable"><em class="xref std std-term">reachable</em></a> from your roots, or any objects
that have been registered for <a class="reference internal" href="../glossary/f.html#term-finalization"><em class="xref std std-term">finalization</em></a> but not yet
finalized, and then to carry on running the <a class="reference internal" href="../glossary/g.html#term-garbage-collector"><em class="xref std std-term">garbage
collector</em></a>.</p>
<p>Our recommended approach is to destroy automatically managed
pools just before destroying the arena, and then only while
the arena is in the <a class="reference internal" href="../glossary/p.html#term-parked-state"><em class="xref std std-term">parked state</em></a>. Thus a safe
tear-down sequence looks like this:</p>
<div class="last highlight-c"><div class="highlight"><pre><span class="n">mps_arena_park</span><span class="p">(</span><span class="n">arena</span><span class="p">);</span>
<span class="cm">/* destroy threads and roots belonging to the arena */</span>
<span class="cm">/* destroy allocation points and caches belonging to the pool */</span>
<span class="n">mps_pool_destroy</span><span class="p">(</span><span class="n">pool</span><span class="p">);</span>
<span class="cm">/* destroy chains and formats belonging to the arena */</span>
<span class="n">mps_arena_destroy</span><span class="p">(</span><span class="n">arena</span><span class="p">);</span>
</pre></div>
</div>
</div>
</dd></dl>
<div class="section" id="pool-classes">

11
mps/manual/html/topic/scanning.html
View file

@ -107,8 +107,8 @@ <h3>Navigation</h3>
passing them to <a class="reference internal" href="#MPS_FIX1" title="MPS_FIX1"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX1()</span></tt></a> and <a class="reference internal" href="#MPS_FIX2" title="MPS_FIX2"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX2()</span></tt></a>.</p>
<p>The reference passed to <a class="reference internal" href="#MPS_FIX2" title="MPS_FIX2"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX2()</span></tt></a> must be the address of the
base of the block referred to (unless the referent belongs to an
<a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> of variant auto-header, in which case it must be
a reference to the address just after the header).</p>
<a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>, in which case it
must be a reference to the address just after the header).</p>
<p>However, <a class="reference internal" href="#MPS_FIX1" title="MPS_FIX1"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX1()</span></tt></a> allows some leeway: if you pass it a
reference to the interior of an allocated block, then
<a class="reference internal" href="#MPS_FIX1" title="MPS_FIX1"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX1()</span></tt></a> correctly determines whether a reference to the
@ -135,7 +135,7 @@ <h3>Navigation</h3>
<p>Similarly, if you use interior pointers, you do not need to convert
them to base pointers before calling <a class="reference internal" href="#MPS_FIX1" title="MPS_FIX1"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX1()</span></tt></a> (or, indeed,
before calling <a class="reference internal" href="#MPS_FIX2" title="MPS_FIX2"><tt class="xref c c-func docutils literal"><span class="pre">MPS_FIX2()</span></tt></a>, if the target of the referent
belongs to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> of variant auto-header).</p>
belongs to an <a class="reference internal" href="../glossary/o.html#term-object-format"><em class="xref std std-term">object format</em></a> with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>).</p>
</div>
<div class="section" id="critical-path">
<span id="index-3"></span><h2>8.3. Critical path<a class="headerlink" href="#critical-path" title="Permalink to this headline"></a></h2>
@ -455,9 +455,8 @@ <h3>Navigation</h3>
restore the tag to the (possibly updated) reference
afterwards.</p>
<p class="last">The only exception is for references to objects belonging to a
format of variant auto-header (see
<a class="reference internal" href="format.html#mps_fmt_auto_header_s" title="mps_fmt_auto_header_s"><tt class="xref c c-type docutils literal"><span class="pre">mps_fmt_auto_header_s</span></tt></a>): the header size must not be
subtracted from these references.</p>
format with <a class="reference internal" href="../glossary/i.html#term-in-band-header"><em class="xref std std-term">in-band headers</em></a>: the header size must not
be subtracted from these references.</p>
</div>
<div class="admonition-note admonition">
<p class="first admonition-title">Note</p>