RubyGems - pango - Versions diffs - 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32 - Mend

pango 0.90.5-x86-mingw32 → 0.90.6-x86-mingw32

Files changed (1348) hide show

data/vendor/local/share/gtk-doc/html/glib/glib-data-types.html DELETED

@@ -1,120 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>GLib Data Types</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="GLib Reference Manual">
-<link rel="up" href="index.html" title="GLib Reference Manual">
-<link rel="prev" href="glib-Windows-Compatibility-Functions.html" title="Windows Compatibility Functions">
-<link rel="next" href="glib-Memory-Slices.html" title="Memory Slices">
-<meta name="generator" content="GTK-Doc V1.15.1 (XML mode)">
-<link rel="stylesheet" href="style.css" type="text/css">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
-<td><a accesskey="p" href="glib-Windows-Compatibility-Functions.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td> </td>
-<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
-<th width="100%" align="center">GLib Reference Manual</th>
-<td><a accesskey="n" href="glib-Memory-Slices.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
-</tr></table>
-<div class="chapter">
-<div class="titlepage"><div><div><h2 class="title">
-<a name="glib-data-types"></a>GLib Data Types</h2></div></div></div>
-<div class="toc"><dl>
-<dt>
-<span class="refentrytitle"><a href="glib-Memory-Slices.html">Memory Slices</a></span><span class="refpurpose"> — efficient way to allocate groups of equal-sized chunks of memory</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Memory-Chunks.html">Memory Chunks</a></span><span class="refpurpose"> — deprecated way to allocate groups of equal-sized
-                    chunks of memory</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Doubly-Linked-Lists.html">Doubly-Linked Lists</a></span><span class="refpurpose"> — linked lists containing integer values or
-                    pointers to data, with the ability to iterate
-                    over the list in both directions</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Singly-Linked-Lists.html">Singly-Linked Lists</a></span><span class="refpurpose"> — linked lists containing integer values or
-                    pointers to data, limited to iterating over the
-                    list in one direction</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Double-ended-Queues.html">Double-ended Queues</a></span><span class="refpurpose"> — double-ended queue data structure</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Sequences.html">Sequences</a></span><span class="refpurpose"> — scalable lists</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Trash-Stacks.html">Trash Stacks</a></span><span class="refpurpose"> — maintain a stack of unused allocated memory chunks</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Hash-Tables.html">Hash Tables</a></span><span class="refpurpose"> — associations between keys and values so that
-                    given a key the value can be found quickly</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Strings.html">Strings</a></span><span class="refpurpose"> — text buffers which grow automatically as text is added</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-String-Chunks.html">String Chunks</a></span><span class="refpurpose"> — efficient storage of groups of strings</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Arrays.html">Arrays</a></span><span class="refpurpose"> — arrays of arbitrary elements which grow
-                    automatically as elements are added</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Pointer-Arrays.html">Pointer Arrays</a></span><span class="refpurpose"> — arrays of pointers to any type of data, which
-                    grow automatically as new elements are added</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Byte-Arrays.html">Byte Arrays</a></span><span class="refpurpose"> — arrays of bytes, which grow automatically as
-                    elements are added</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Balanced-Binary-Trees.html">Balanced Binary Trees</a></span><span class="refpurpose"> — a sorted collection of key/value pairs optimized
-                    for searching and traversing in order</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-N-ary-Trees.html">N-ary Trees</a></span><span class="refpurpose"> — trees of data with any number of branches</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Quarks.html">Quarks</a></span><span class="refpurpose"> — a 2-way association between a string and a
-                    unique integer identifier</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Keyed-Data-Lists.html">Keyed Data Lists</a></span><span class="refpurpose"> — lists of data elements which are accessible by a
-                    string or GQuark identifier</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Datasets.html">Datasets</a></span><span class="refpurpose"> — associate groups of data elements with
-                    particular memory locations</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Relations-and-Tuples.html">Relations and Tuples</a></span><span class="refpurpose"> — tables of data which can be indexed on any
-                    number of fields</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Caches.html">Caches</a></span><span class="refpurpose"> — caches allow sharing of complex data structures
-                    to save resources</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Memory-Allocators.html">Memory Allocators</a></span><span class="refpurpose"> — deprecated way to allocate chunks of memory for
-                    GList, GSList and GNode</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-GVariantType.html">GVariantType</a></span><span class="refpurpose"> — introduction to the GVariant type system</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-GVariant.html">GVariant</a></span><span class="refpurpose"> — strongly typed value datatype</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="gvariant-format-strings.html">GVariant Format Strings</a></span><span class="refpurpose"></span>
-</dt>
-</dl></div>
-</div>
-<div class="footer">
-<hr>
-          Generated by GTK-Doc V1.15.1</div>
-</body>
-</html>

data/vendor/local/share/gtk-doc/html/glib/glib-fundamentals.html DELETED

@@ -1,59 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>GLib Fundamentals</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="GLib Reference Manual">
-<link rel="up" href="index.html" title="GLib Reference Manual">
-<link rel="prev" href="glib-resources.html" title="Mailing lists and bug reports">
-<link rel="next" href="glib-Version-Information.html" title="Version Information">
-<meta name="generator" content="GTK-Doc V1.15.1 (XML mode)">
-<link rel="stylesheet" href="style.css" type="text/css">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
-<td><a accesskey="p" href="glib-resources.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td> </td>
-<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
-<th width="100%" align="center">GLib Reference Manual</th>
-<td><a accesskey="n" href="glib-Version-Information.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
-</tr></table>
-<div class="chapter">
-<div class="titlepage"><div><div><h2 class="title">
-<a name="glib-fundamentals"></a>GLib Fundamentals</h2></div></div></div>
-<div class="toc"><dl>
-<dt>
-<span class="refentrytitle"><a href="glib-Version-Information.html">Version Information</a></span><span class="refpurpose"> — Variables and functions to check the GLib version</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Basic-Types.html">Basic Types</a></span><span class="refpurpose"> — standard GLib types, defined for ease-of-use and portability</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Limits-of-Basic-Types.html">Limits of Basic Types</a></span><span class="refpurpose"> — portable method of determining the limits of the standard types</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Standard-Macros.html">Standard Macros</a></span><span class="refpurpose"> — commonly-used macros.</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Type-Conversion-Macros.html">Type Conversion Macros</a></span><span class="refpurpose"> — portably storing integers in pointer variables</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Byte-Order-Macros.html">Byte Order Macros</a></span><span class="refpurpose"> — a portable way to convert between different byte orders</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Numerical-Definitions.html">Numerical Definitions</a></span><span class="refpurpose"> — mathematical constants, and floating point decomposition</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Miscellaneous-Macros.html">Miscellaneous Macros</a></span><span class="refpurpose"> — specialized macros which are not used often</span>
-</dt>
-<dt>
-<span class="refentrytitle"><a href="glib-Atomic-Operations.html">Atomic Operations</a></span><span class="refpurpose"> — basic atomic integer and pointer operations</span>
-</dt>
-</dl></div>
-</div>
-<div class="footer">
-<hr>
-          Generated by GTK-Doc V1.15.1</div>
-</body>
-</html>

data/vendor/local/share/gtk-doc/html/glib/glib-gettextize.html DELETED

@@ -1,93 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>glib-gettextize</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="GLib Reference Manual">
-<link rel="up" href="tools.html" title="GLib Tools">
-<link rel="prev" href="tools.html" title="GLib Tools">
-<link rel="next" href="gtester.html" title="gtester">
-<meta name="generator" content="GTK-Doc V1.15.1 (XML mode)">
-<link rel="stylesheet" href="style.css" type="text/css">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
-<td><a accesskey="p" href="tools.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td><a accesskey="u" href="tools.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
-<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
-<th width="100%" align="center">GLib Reference Manual</th>
-<td><a accesskey="n" href="gtester.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
-</tr></table>
-<div lang="en" class="refentry">
-<a name="glib-gettextize"></a><div class="titlepage"></div>
-<div class="refnamediv"><table width="100%"><tr>
-<td valign="top">
-<h2><span class="refentrytitle">glib-gettextize</span></h2>
-<p>glib-gettextize — gettext internationalization utility</p>
-</td>
-<td valign="top" align="right"></td>
-</tr></table></div>
-<div class="refsynopsisdiv">
-<h2>Synopsis</h2>
-<div class="cmdsynopsis"><p><code class="command">glib-gettextize</code>  [option...] [directory]</p></div>
-</div>
-<div class="refsect1">
-<a name="id550500"></a><h2>Description</h2>
-<p><span class="command"><strong>glib-gettextize</strong></span> helps to prepare a source package for being
-internationalized through <span class="application">gettext</span>.
-It is a variant of the <span class="command"><strong>gettextize</strong></span> that ships with
-<span class="application">gettext</span>.
-</p>
-<p><span class="command"><strong>glib-gettextize</strong></span> differs
-from <span class="command"><strong>gettextize</strong></span> in that it doesn't create an
-<code class="filename">intl/</code> subdirectory and doesn't modify
-<code class="filename">po/ChangeLog</code> (note that newer versions of
-<span class="command"><strong>gettextize</strong></span> behave like this when called with the
-<code class="option">--no-changelog</code> option).
-</p>
-<div class="refsect2">
-<a name="id537457"></a><h3>Options</h3>
-<div class="variablelist"><table border="0">
-<col align="left" valign="top">
-<tbody>
-<tr>
-<td><p><span class="term"><code class="option">--help</code></span></p></td>
-<td><p>
-print help and exit
-</p></td>
-</tr>
-<tr>
-<td><p><span class="term"><code class="option">--version</code></span></p></td>
-<td><p>
-print version information and exit
-</p></td>
-</tr>
-<tr>
-<td><p><span class="term"><code class="option">-c</code>, <code class="option">--copy</code></span></p></td>
-<td><p>
-copy files instead of making symlinks
-</p></td>
-</tr>
-<tr>
-<td><p><span class="term"><code class="option">-f</code>, <code class="option">--force</code></span></p></td>
-<td><p>
-force writing of new files even if old ones exist
-</p></td>
-</tr>
-</tbody>
-</table></div>
-</div>
-</div>
-<div class="refsect1">
-<a name="id589723"></a><h2>See also</h2>
-<p>
-<span class="citerefentry"><span class="refentrytitle">gettextize</span>(1)</span>
-</p>
-</div>
-</div>
-<div class="footer">
-<hr>
-          Generated by GTK-Doc V1.15.1</div>
-</body>
-</html>

data/vendor/local/share/gtk-doc/html/glib/glib-regex-syntax.html DELETED

@@ -1,2217 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>Regular expression syntax</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
-<link rel="home" href="index.html" title="GLib Reference Manual">
-<link rel="up" href="glib.html" title="GLib Overview">
-<link rel="prev" href="glib-changes.html" title="Changes to GLib">
-<link rel="next" href="glib-resources.html" title="Mailing lists and bug reports">
-<meta name="generator" content="GTK-Doc V1.15.1 (XML mode)">
-<link rel="stylesheet" href="style.css" type="text/css">
-</head>
-<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
-<table class="navigation" id="top" width="100%" summary="Navigation header" cellpadding="2" cellspacing="2"><tr valign="middle">
-<td><a accesskey="p" href="glib-changes.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td><a accesskey="u" href="glib.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
-<td><a accesskey="h" href="index.html"><img src="home.png" width="24" height="24" border="0" alt="Home"></a></td>
-<th width="100%" align="center">GLib Reference Manual</th>
-<td><a accesskey="n" href="glib-resources.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
-</tr></table>
-<div class="refentry">
-<a name="glib-regex-syntax"></a><div class="titlepage"></div>
-<div class="refnamediv"><table width="100%"><tr>
-<td valign="top">
-<h2><span class="refentrytitle">Regular expression syntax</span></h2>
-<p>Regular expression syntax —
-Syntax and semantics of the regular expressions supported by GRegex
-</p>
-</td>
-<td valign="top" align="right"></td>
-</tr></table></div>
-<div class="refsect1">
-<a name="id556931"></a><h2>GRegex regular expression details</h2>
-<p>
-A regular expression is a pattern that is matched against a
-string from left to right. Most characters stand for themselves in a
-pattern, and match the corresponding characters in the string. As a
-trivial example, the pattern
-</p>
-<pre class="programlisting">
-The quick brown fox
-</pre>
-<p>
-matches a portion of a string that is identical to itself. When
-caseless matching is specified (the <code class="varname">G_REGEX_CASELESS</code> flag), letters are
-matched independently of case.
-</p>
-<p>
-The power of regular expressions comes from the ability to include
-alternatives and repetitions in the pattern. These are encoded in the
-pattern by the use of metacharacters, which do not stand for themselves
-but instead are interpreted in some special way.
-</p>
-<p>
-There are two different sets of metacharacters: those that are recognized
-anywhere in the pattern except within square brackets, and those
-that are recognized in square brackets. Outside square brackets, the
-metacharacters are as follows:
-</p>
-<div class="table">
-<a name="id531576"></a><p class="title"><b>Table 1. Metacharacters outside square brackets</b></p>
-<div class="table-contents"><table summary="Metacharacters outside square brackets" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Character</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\</td>
-<td>general escape character with several uses</td>
-</tr>
-<tr>
-<td align="center">^</td>
-<td>assert start of string (or line, in multiline mode)</td>
-</tr>
-<tr>
-<td align="center">$</td>
-<td>assert end of string (or line, in multiline mode)</td>
-</tr>
-<tr>
-<td align="center">.</td>
-<td>match any character except newline (by default)</td>
-</tr>
-<tr>
-<td align="center">[</td>
-<td>start character class definition</td>
-</tr>
-<tr>
-<td align="center">|</td>
-<td>start of alternative branch</td>
-</tr>
-<tr>
-<td align="center">(</td>
-<td>start subpattern</td>
-</tr>
-<tr>
-<td align="center">)</td>
-<td>end subpattern</td>
-</tr>
-<tr>
-<td align="center">?</td>
-<td>extends the meaning of (, or 0/1 quantifier, or quantifier minimizer</td>
-</tr>
-<tr>
-<td align="center">*</td>
-<td>0 or more quantifier</td>
-</tr>
-<tr>
-<td align="center">+</td>
-<td>1 or more quantifier, also "possessive quantifier"</td>
-</tr>
-<tr>
-<td align="center">{</td>
-<td>start min/max quantifier</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-Part of a pattern that is in square brackets is called a "character
-class". In a character class the only metacharacters are:
-</p>
-<div class="table">
-<a name="id559052"></a><p class="title"><b>Table 2. Metacharacters inside square brackets</b></p>
-<div class="table-contents"><table summary="Metacharacters inside square brackets" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Character</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\</td>
-<td>general escape character</td>
-</tr>
-<tr>
-<td align="center">^</td>
-<td>negate the class, but only if the first character</td>
-</tr>
-<tr>
-<td align="center">-</td>
-<td>indicates character range</td>
-</tr>
-<tr>
-<td align="center">[</td>
-<td>POSIX character class (only if followed by POSIX syntax)</td>
-</tr>
-<tr>
-<td align="center">]</td>
-<td>terminates the character class</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break">
-</div>
-<div class="refsect1">
-<a name="id571714"></a><h2>Backslash</h2>
-<p>
-The backslash character has several uses. Firstly, if it is followed by
-a non-alphanumeric character, it takes away any special meaning that
-character may have. This use of backslash as an escape character
-applies both inside and outside character classes.
-</p>
-<p>
-For example, if you want to match a * character, you write \* in the
-pattern. This escaping action applies whether or not the following
-character would otherwise be interpreted as a metacharacter, so it is
-always safe to precede a non-alphanumeric with backslash to specify
-that it stands for itself. In particular, if you want to match a
-backslash, you write \\.
-</p>
-<p>
-If a pattern is compiled with the <code class="varname">G_REGEX_EXTENDED</code>
-option, whitespace in the pattern (other than in a character class) and
-characters between a # outside a character class and the next newline
-are ignored.
-An escaping backslash can be used to include a whitespace or # character
-as part of the pattern.
-</p>
-<p>
-Note that the C compiler interprets backslash in strings itself, therefore
-you need to duplicate all \ characters when you put a regular expression
-in a C string, like "\\d{3}".
-</p>
-<p>
-If you want to remove the special meaning from a sequence of characters,
-you can do so by putting them between \Q and \E.
-The \Q...\E sequence is recognized both inside and outside character
-classes.
-</p>
-<div class="refsect2">
-<a name="id529421"></a><h3>Non-printing characters</h3>
-<p>
-A second use of backslash provides a way of encoding non-printing
-characters in patterns in a visible manner. There is no restriction on the
-appearance of non-printing characters, apart from the binary zero that
-terminates a pattern, but when a pattern is being prepared by text
-editing, it is usually easier to use one of the following escape
-sequences than the binary character it represents:
-</p>
-<div class="table">
-<a name="id529434"></a><p class="title"><b>Table 3. Non-printing characters</b></p>
-<div class="table-contents"><table summary="Non-printing characters" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Escape</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\a</td>
-<td>alarm, that is, the BEL character (hex 07)</td>
-</tr>
-<tr>
-<td align="center">\cx</td>
-<td>"control-x", where x is any character</td>
-</tr>
-<tr>
-<td align="center">\e</td>
-<td>escape (hex 1B)</td>
-</tr>
-<tr>
-<td align="center">\f</td>
-<td>formfeed (hex 0C)</td>
-</tr>
-<tr>
-<td align="center">\n</td>
-<td>newline (hex 0A)</td>
-</tr>
-<tr>
-<td align="center">\r</td>
-<td>carriage return (hex 0D)</td>
-</tr>
-<tr>
-<td align="center">\t</td>
-<td>tab (hex 09)</td>
-</tr>
-<tr>
-<td align="center">\ddd</td>
-<td>character with octal code ddd, or backreference</td>
-</tr>
-<tr>
-<td align="center">\xhh</td>
-<td>character with hex code hh</td>
-</tr>
-<tr>
-<td align="center">\x{hhh..}</td>
-<td>character with hex code hhh..</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-The precise effect of \cx is as follows: if x is a lower case letter,
-it is converted to upper case. Then bit 6 of the character (hex 40) is
-inverted. Thus \cz becomes hex 1A, but \c{ becomes hex 3B, while \c;
-becomes hex 7B.
-</p>
-<p>
-After \x, from zero to two hexadecimal digits are read (letters can be
-in upper or lower case). Any number of hexadecimal digits may appear
-between \x{ and }, but the value of the character code
-must be less than 2**31 (that is, the maximum hexadecimal value is
-7FFFFFFF). If characters other than hexadecimal digits appear between
-\x{ and }, or if there is no terminating }, this form of escape is not
-recognized. Instead, the initial \x will be interpreted as a basic hexadecimal
-escape, with no following digits, giving a character whose
-value is zero.
-</p>
-<p>
-Characters whose value is less than 256 can be defined by either of the
-two syntaxes for \x. There is no difference
-in the way they are handled. For example, \xdc is exactly the same as
-\x{dc}.
-</p>
-<p>
-After \0 up to two further octal digits are read. If there are fewer
-than two digits, just those that are present are used.
-Thus the sequence \0\x\07 specifies two binary zeros followed by a BEL
-character (code value 7). Make sure you supply two digits after the
-initial zero if the pattern character that follows is itself an octal
-digit.
-</p>
-<p>
-The handling of a backslash followed by a digit other than 0 is complicated.
-Outside a character class, GRegex reads it and any following digits as a
-decimal number. If the number is less than 10, or if there
-have been at least that many previous capturing left parentheses in the
-expression, the entire sequence is taken as a back reference. A
-description of how this works is given later, following the discussion
-of parenthesized subpatterns.
-</p>
-<p>
-Inside a character class, or if the decimal number is greater than 9
-and there have not been that many capturing subpatterns, GRegex re-reads
-up to three octal digits following the backslash, and uses them to generate
-a data character. Any subsequent digits stand for themselves. For example:
-</p>
-<div class="table">
-<a name="id526751"></a><p class="title"><b>Table 4. Non-printing characters</b></p>
-<div class="table-contents"><table summary="Non-printing characters" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Escape</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\040</td>
-<td>is another way of writing a space</td>
-</tr>
-<tr>
-<td align="center">\40</td>
-<td>is the same, provided there are fewer than 40 previous capturing subpatterns</td>
-</tr>
-<tr>
-<td align="center">\7</td>
-<td>is always a back reference</td>
-</tr>
-<tr>
-<td align="center">\11</td>
-<td>might be a back reference, or another way of writing a tab</td>
-</tr>
-<tr>
-<td align="center">\011</td>
-<td>is always a tab</td>
-</tr>
-<tr>
-<td align="center">\0113</td>
-<td>is a tab followed by the character "3"</td>
-</tr>
-<tr>
-<td align="center">\113</td>
-<td>might be a back reference, otherwise the character with octal code 113</td>
-</tr>
-<tr>
-<td align="center">\377</td>
-<td>might be a back reference, otherwise the byte consisting entirely of 1 bits</td>
-</tr>
-<tr>
-<td align="center">\81</td>
-<td>is either a back reference, or a binary zero followed by the two characters "8" and "1"</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-Note that octal values of 100 or greater must not be introduced by a
-leading zero, because no more than three octal digits are ever read.
-</p>
-<p>
-All the sequences that define a single character can be used both inside
-and outside character classes. In addition, inside a character class, the
-sequence \b is interpreted as the backspace character (hex 08), and the
-sequences \R and \X are interpreted as the characters "R" and "X", respectively.
-Outside a character class, these sequences have different meanings (see below).
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id526910"></a><h3>Absolute and relative back references</h3>
-<p>
-The sequence \g followed by a positive or negative number, optionally enclosed
-in braces, is an absolute or relative back reference. Back references are
-discussed later, following the discussion of parenthesized subpatterns.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id526923"></a><h3>Generic character types</h3>
-<p>
-Another use of backslash is for specifying generic character types.
-The following are always recognized:
-</p>
-<div class="table">
-<a name="id526934"></a><p class="title"><b>Table 5. Generic characters</b></p>
-<div class="table-contents"><table summary="Generic characters" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Escape</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\d</td>
-<td>any decimal digit</td>
-</tr>
-<tr>
-<td align="center">\D</td>
-<td>any character that is not a decimal digit</td>
-</tr>
-<tr>
-<td align="center">\s</td>
-<td>any whitespace character</td>
-</tr>
-<tr>
-<td align="center">\S</td>
-<td>any character that is not a whitespace character</td>
-</tr>
-<tr>
-<td align="center">\w</td>
-<td>any "word" character</td>
-</tr>
-<tr>
-<td align="center">\W</td>
-<td>any "non-word" character</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-Each pair of escape sequences partitions the complete set of characters
-into two disjoint sets. Any given character matches one, and only one,
-of each pair.
-</p>
-<p>
-These character type sequences can appear both inside and outside character
-classes. They each match one character of the appropriate type.
-If the current matching point is at the end of the passed string, all
-of them fail, since there is no character to match.
-</p>
-<p>
-For compatibility with Perl, \s does not match the VT character (code
-11). This makes it different from the the POSIX "space" class. The \s
-characters are HT (9), LF (10), FF (12), CR (13), and space (32).
-</p>
-<p>
-A "word" character is an underscore or any character less than 256 that
-is a letter or digit.</p>
-<p>
-Characters with values greater than 128 never match \d,
-\s, or \w, and always match \D, \S, and \W.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id527073"></a><h3>Newline sequences</h3>
-<p>Outside a character class, the escape sequence \R matches any Unicode
-newline sequence.
-This particular group matches either the two-character sequence CR followed by
-LF, or one of the single characters LF (linefeed, U+000A), VT (vertical tab,
-U+000B), FF (formfeed, U+000C), CR (carriage return, U+000D), NEL (next
-line, U+0085), LS (line separator, U+2028), or PS (paragraph separator, U+2029).
-The two-character sequence is treated as a single unit that
-cannot be split. Inside a character class, \R matches the letter "R".</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id527088"></a><h3>Unicode character properties</h3>
-<p>
-To support generic character types there are three additional escape
-sequences, they are:
-</p>
-<div class="table">
-<a name="id527099"></a><p class="title"><b>Table 6. Generic character types</b></p>
-<div class="table-contents"><table summary="Generic character types" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Escape</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\p{xx}</td>
-<td>a character with the xx property</td>
-</tr>
-<tr>
-<td align="center">\P{xx}</td>
-<td>a character without the xx property</td>
-</tr>
-<tr>
-<td align="center">\X</td>
-<td>an extended Unicode sequence</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-The property names represented by xx above are limited to the Unicode
-script names, the general category properties, and "Any", which matches
-any character (including newline). Other properties such as "InMusicalSymbols"
-are not currently supported. Note that \P{Any} does not match any characters,
-so always causes a match failure.
-</p>
-<p>
-Sets of Unicode characters are defined as belonging to certain scripts. A
-character from one of these sets can be matched using a script name. For
-example, \p{Greek} or \P{Han}.
-</p>
-<p>
-Those that are not part of an identified script are lumped together as
-"Common". The current list of scripts can be found in the documentation for
-the #GUnicodeScript enumeration. Script names for use with \p{} can be
-found by replacing all spaces with underscores, e.g. for Linear B use
-\p{Linear_B}.
-</p>
-<p>
-Each character has exactly one general category property, specified by a
-two-letter abbreviation. For compatibility with Perl, negation can be specified
-by including a circumflex between the opening brace and the property name. For
-example, \p{^Lu} is the same as \P{Lu}.
-</p>
-<p>
-If only one letter is specified with \p or \P, it includes all the general
-category properties that start with that letter. In this case, in the absence
-of negation, the curly brackets in the escape sequence are optional; these two
-examples have the same effect:
-</p>
-<pre class="programlisting">
-\p{L}
-\pL
-</pre>
-<p>
-In addition to the two-letter category codes listed in the
-documentation for the #GUnicodeType enumeration, the following
-general category property codes are supported:
-</p>
-<div class="table">
-<a name="id527219"></a><p class="title"><b>Table 7. Property codes</b></p>
-<div class="table-contents"><table summary="Property codes" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Code</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">C</td>
-<td>Other</td>
-</tr>
-<tr>
-<td align="center">L</td>
-<td>Letter</td>
-</tr>
-<tr>
-<td align="center">M</td>
-<td>Mark</td>
-</tr>
-<tr>
-<td align="center">N</td>
-<td>Number</td>
-</tr>
-<tr>
-<td align="center">P</td>
-<td>Punctuation</td>
-</tr>
-<tr>
-<td align="center">S</td>
-<td>Symbol</td>
-</tr>
-<tr>
-<td align="center">Z</td>
-<td>Separator</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-The special property L&amp; is also supported: it matches a character that has
-the Lu, Ll, or Lt property, in other words, a letter that is not classified as
-a modifier or "other".
-</p>
-<p>
-The long synonyms for these properties that Perl supports (such as \ep{Letter})
-are not supported by GRegex, nor is it permitted to prefix any of these
-properties with "Is".
-</p>
-<p>
-No character that is in the Unicode table has the Cn (unassigned) property.
-Instead, this property is assumed for any code point that is not in the
-Unicode table.
-</p>
-<p>
-Specifying caseless matching does not affect these escape sequences.
-For example, \p{Lu} always matches only upper case letters.
-</p>
-<p>
-The \X escape matches any number of Unicode characters that form an
-extended Unicode sequence. \X is equivalent to
-</p>
-<pre class="programlisting">
-(?&gt;\PM\pM*)
-</pre>
-<p>
-That is, it matches a character without the "mark" property, followed
-by zero or more characters with the "mark" property, and treats the
-sequence as an atomic group (see below). Characters with the "mark"
-property are typically accents that affect the preceding character.
-</p>
-<p>
-Matching characters by Unicode property is not fast, because GRegex has
-to search a structure that contains data for over fifteen thousand
-characters. That is why the traditional escape sequences such as \d and
-\w do not use Unicode properties.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id527386"></a><h3>Simple assertions</h3>
-<p>
-The final use of backslash is for certain simple assertions. An
-assertion specifies a condition that has to be met at a particular point in
-a match, without consuming any characters from the string. The
-use of subpatterns for more complicated assertions is described below.
-The backslashed assertions are:
-</p>
-<div class="table">
-<a name="id527399"></a><p class="title"><b>Table 8. Simple assertions</b></p>
-<div class="table-contents"><table summary="Simple assertions" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Escape</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">\b</td>
-<td>matches at a word boundary</td>
-</tr>
-<tr>
-<td align="center">\B</td>
-<td>matches when not at a word boundary</td>
-</tr>
-<tr>
-<td align="center">\A</td>
-<td>matches at the start of the string</td>
-</tr>
-<tr>
-<td align="center">\Z</td>
-<td>matches at the end of the string or before a newline at the end of the string</td>
-</tr>
-<tr>
-<td align="center">\z</td>
-<td>matches only at the end of the string</td>
-</tr>
-<tr>
-<td align="center">\G</td>
-<td>matches at first matching position in the string</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-These assertions may not appear in character classes (but note that \b
-has a different meaning, namely the backspace character, inside a
-character class).
-</p>
-<p>
-A word boundary is a position in the string where the current
-character and the previous character do not both match \w or \W (i.e.
-one matches \w and the other matches \W), or the start or end of the
-string if the first or last character matches \w, respectively.
-</p>
-<p>
-The \A, \Z, and \z assertions differ from the traditional circumflex
-and dollar (described in the next section) in that they only ever match
-at the very start and end of the string, whatever options are
-set. Thus, they are independent of multiline mode. These three assertions
-are not affected by the <code class="varname">G_REGEX_MATCH_NOTBOL</code> or <code class="varname">G_REGEX_MATCH_NOTEOL</code> options,
-which affect only the behaviour of the circumflex and dollar metacharacters.
-However, if the start_position argument of a matching function is non-zero,
-indicating that matching is to start at a point other than the beginning of
-the string, \A can never match. The difference between \Z and \z is
-that \Z matches before a newline at the end of the string as well at the
-very end, whereas \z matches only at the end.
-</p>
-<p>
-The \G assertion is true only when the current matching position is at
-the start point of the match, as specified by the start_position argument
-to the matching functions. It differs from \A when the value of startoffset is
-non-zero.
-</p>
-<p>
-Note, however, that the interpretation of \G, as the start of the
-current match, is subtly different from Perl’s, which defines it as the
-end of the previous match. In Perl, these can be different when the
-previously matched string was empty.
-</p>
-<p>
-If all the alternatives of a pattern begin with \G, the expression is
-anchored to the starting match position, and the "anchored" flag is set
-in the compiled regular expression.
-</p>
-</div>
-</div>
-<div class="refsect1">
-<a name="id527558"></a><h2>Circumflex and dollar</h2>
-<p>
-Outside a character class, in the default matching mode, the circumflex
-character is an assertion that is true only if the current matching
-point is at the start of the string. If the start_position argument to
-the matching functions is non-zero, circumflex can never match if the
-<code class="varname">G_REGEX_MULTILINE</code> option is unset. Inside a character class, circumflex
-has an entirely different meaning (see below).
-</p>
-<p>
-Circumflex need not be the first character of the pattern if a number
-of alternatives are involved, but it should be the first thing in each
-alternative in which it appears if the pattern is ever to match that
-branch. If all possible alternatives start with a circumflex, that is,
-if the pattern is constrained to match only at the start of the string,
-it is said to be an "anchored" pattern. (There are also other
-constructs that can cause a pattern to be anchored.)
-</p>
-<p>
-A dollar character is an assertion that is true only if the current
-matching point is at the end of the string, or immediately
-before a newline at the end of the string (by default). Dollar need not
-be the last character of the pattern if a number of alternatives are
-involved, but it should be the last item in any branch in which it
-appears. Dollar has no special meaning in a character class.
-</p>
-<p>
-The meaning of dollar can be changed so that it matches only at the
-very end of the string, by setting the <code class="varname">G_REGEX_DOLLAR_ENDONLY</code> option at
-compile time. This does not affect the \Z assertion.
-</p>
-<p>
-The meanings of the circumflex and dollar characters are changed if the
-<code class="varname">G_REGEX_MULTILINE</code> option is set. When this is the case,
-a circumflex matches immediately after internal newlines as well as at the
-start of the string. It does not match after a newline that ends the string.
-A dollar matches before any newlines in the string, as well as at the very
-end, when <code class="varname">G_REGEX_MULTILINE</code> is set. When newline is
-specified as the two-character sequence CRLF, isolated CR and LF characters
-do not indicate newlines.
-</p>
-<p>
-For example, the pattern /^abc$/ matches the string "def\nabc" (where
-\n represents a newline) in multiline mode, but not otherwise. Consequently,
-patterns that are anchored in single line mode because all branches start with
-^ are not anchored in multiline mode, and a match for circumflex is possible
-when the <code class="varname">start_position</code> argument of a matching function
-is non-zero. The <code class="varname">G_REGEX_DOLLAR_ENDONLY</code> option is ignored
-if <code class="varname">G_REGEX_MULTILINE</code> is set.
-</p>
-<p>
-Note that the sequences \A, \Z, and \z can be used to match the start and
-end of the string in both modes, and if all branches of a pattern start with
-\A it is always anchored, whether or not <code class="varname">G_REGEX_MULTILINE</code>
-is set.
-</p>
-</div>
-<div class="refsect1">
-<a name="id527639"></a><h2>Full stop (period, dot)</h2>
-<p>
-Outside a character class, a dot in the pattern matches any one character
-in the string, including a non-printing character, but not (by
-default) newline. In UTF-8 a character might be more than one byte long.
-</p>
-<p>
-When a line ending is defined as a single character, dot never matches that
-character; when the two-character sequence CRLF is used, dot does not match CR
-if it is immediately followed by LF, but otherwise it matches all characters
-(including isolated CRs and LFs). When any Unicode line endings are being
-recognized, dot does not match CR or LF or any of the other line ending
-characters.
-</p>
-<p>
-If the <code class="varname">G_REGEX_DOTALL</code> flag is set, dots match newlines
-as well. The handling of dot is entirely independent of the handling of circumflex
-and dollar, the only relationship being that they both involve newline
-characters. Dot has no special meaning in a character class.
-</p>
-<p>
-The behaviour of dot with regard to newlines can be changed. If the
-<code class="varname">G_REGEX_DOTALL</code> option is set, a dot matches any one
-character, without exception. If newline is defined as the two-character
-sequence CRLF, it takes two dots to match it.
-</p>
-<p>
-The handling of dot is entirely independent of the handling of circumflex and
-dollar, the only relationship being that they both involve newlines. Dot has no
-special meaning in a character class.
-</p>
-</div>
-<div class="refsect1">
-<a name="id527682"></a><h2>Matching a single byte</h2>
-<p>
-Outside a character class, the escape sequence \C matches any one byte,
-both in and out of UTF-8 mode. Unlike a dot, it always matches any line
-ending characters.
-The feature is provided in Perl in order to match individual bytes in
-UTF-8 mode. Because it breaks up UTF-8 characters into individual
-bytes, what remains in the string may be a malformed UTF-8 string. For
-this reason, the \C escape sequence is best avoided.
-</p>
-<p>
-GRegex does not allow \C to appear in lookbehind assertions (described
-below), because in UTF-8 mode this would make it impossible to calculate
-the length of the lookbehind.
-</p>
-</div>
-<div class="refsect1">
-<a name="id527701"></a><h2>Square brackets and character classes</h2>
-<p>
-An opening square bracket introduces a character class, terminated by a
-closing square bracket. A closing square bracket on its own is not special. If a closing square bracket is required as a member of the class,
-it should be the first data character in the class (after an initial
-circumflex, if present) or escaped with a backslash.
-</p>
-<p>
-A character class matches a single character in the string.  A matched character
-must be in the set of characters defined by the class, unless the first
-character in the class definition is a circumflex, in which case the
-string character must not be in the set defined by the class. If a
-circumflex is actually required as a member of the class, ensure it is
-not the first character, or escape it with a backslash.
-</p>
-<p>
-For example, the character class [aeiou] matches any lower case vowel,
-while [^aeiou] matches any character that is not a lower case vowel.
-Note that a circumflex is just a convenient notation for specifying the
-characters that are in the class by enumerating those that are not. A
-class that starts with a circumflex is not an assertion: it still consumes
-a character from the string, and therefore it fails if the current pointer
-is at the end of the string.
-</p>
-<p>
-In UTF-8 mode, characters with values greater than 255 can be included
-in a class as a literal string of bytes, or by using the \x{ escaping
-mechanism.
-</p>
-<p>
-When caseless matching is set, any letters in a class represent both
-their upper case and lower case versions, so for example, a caseless
-[aeiou] matches "A" as well as "a", and a caseless [^aeiou] does not
-match "A", whereas a caseful version would.
-</p>
-<p>
-Characters that might indicate line breaks are never treated
-in any special way when matching character classes, whatever line-ending
-sequence is in use, and whatever setting of the <code class="varname">G_REGEX_DOTALL</code>
-and <code class="varname">G_REGEX_MULTILINE</code> options is used. A class such as [^a]
-always matches one of these characters.
-</p>
-<p>
-The minus (hyphen) character can be used to specify a range of characters in
-a character class. For example, [d-m] matches any letter
-between d and m, inclusive. If a minus character is required in a
-class, it must be escaped with a backslash or appear in a position
-where it cannot be interpreted as indicating a range, typically as the
-first or last character in the class.
-</p>
-<p>
-It is not possible to have the literal character "]" as the end character
-of a range. A pattern such as [W-]46] is interpreted as a class of
-two characters ("W" and "-") followed by a literal string "46]", so it
-would match "W46]" or "-46]". However, if the "]" is escaped with a
-backslash it is interpreted as the end of range, so [W-\]46] is interpreted
-as a class containing a range followed by two other characters.
-The octal or hexadecimal representation of "]" can also be used to end
-a range.
-</p>
-<p>
-Ranges operate in the collating sequence of character values. They can
-also be used for characters specified numerically, for example
-[\000-\037]. In UTF-8 mode, ranges can include characters whose values
-are greater than 255, for example [\x{100}-\x{2ff}].
-</p>
-<p>
-The character types \d, \D, \p, \P, \s, \S, \w, and \W may also appear
-in a character class, and add the characters that they match to the
-class. For example, [\dABCDEF] matches any hexadecimal digit. A
-circumflex can conveniently be used with the upper case character types to
-specify a more restricted set of characters than the matching lower
-case type. For example, the class [^\W_] matches any letter or digit,
-but not underscore.
-</p>
-<p>
-The only metacharacters that are recognized in character classes are
-backslash, hyphen (only where it can be interpreted as specifying a
-range), circumflex (only at the start), opening square bracket (only
-when it can be interpreted as introducing a POSIX class name - see the
-next section), and the terminating closing square bracket. However,
-escaping other non-alphanumeric characters does no harm.
-</p>
-</div>
-<div class="refsect1">
-<a name="id527787"></a><h2>Posix character classes</h2>
-<p>
-GRegex supports the POSIX notation for character classes. This uses names
-enclosed by [: and :] within the enclosing square brackets. For example,
-</p>
-<pre class="programlisting">
-[01[:alpha:]%]
-</pre>
-<p>
-matches "0", "1", any alphabetic character, or "%". The supported class
-names are
-</p>
-<div class="table">
-<a name="id527808"></a><p class="title"><b>Table 9. Posix classes</b></p>
-<div class="table-contents"><table summary="Posix classes" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Name</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">alnum</td>
-<td>letters and digits</td>
-</tr>
-<tr>
-<td align="center">alpha</td>
-<td>letters</td>
-</tr>
-<tr>
-<td align="center">ascii</td>
-<td>character codes 0 - 127</td>
-</tr>
-<tr>
-<td align="center">blank</td>
-<td>space or tab only</td>
-</tr>
-<tr>
-<td align="center">cntrl</td>
-<td>control characters</td>
-</tr>
-<tr>
-<td align="center">digit</td>
-<td>decimal digits (same as \d)</td>
-</tr>
-<tr>
-<td align="center">graph</td>
-<td>printing characters, excluding space</td>
-</tr>
-<tr>
-<td align="center">lower</td>
-<td>lower case letters</td>
-</tr>
-<tr>
-<td align="center">print</td>
-<td>printing characters, including space</td>
-</tr>
-<tr>
-<td align="center">punct</td>
-<td>printing characters, excluding letters and digits</td>
-</tr>
-<tr>
-<td align="center">space</td>
-<td>white space (not quite the same as \s)</td>
-</tr>
-<tr>
-<td align="center">upper</td>
-<td>upper case letters</td>
-</tr>
-<tr>
-<td align="center">word</td>
-<td>"word" characters (same as \w)</td>
-</tr>
-<tr>
-<td align="center">xdigit</td>
-<td>hexadecimal digits</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-The "space" characters are HT (9), LF (10), VT (11), FF (12), CR (13),
-and space (32). Notice that this list includes the VT character (code
-11). This makes "space" different to \s, which does not include VT (for
-Perl compatibility).
-</p>
-<p>
-The name "word" is a Perl extension, and "blank" is a GNU extension.
-Another Perl extension is negation, which is indicated by a ^ character
-after the colon. For example,
-</p>
-<pre class="programlisting">
-[12[:^digit:]]
-</pre>
-<p>
-matches "1", "2", or any non-digit. GRegex also recognize the
-POSIX syntax [.ch.] and [=ch=] where "ch" is a "collating element", but
-these are not supported, and an error is given if they are encountered.
-</p>
-<p>
-In UTF-8 mode, characters with values greater than 128 do not match any
-of the POSIX character classes.
-</p>
-</div>
-<div class="refsect1">
-<a name="id528038"></a><h2>Vertical bar</h2>
-<p>
-Vertical bar characters are used to separate alternative patterns. For
-example, the pattern
-</p>
-<pre class="programlisting">
- gilbert|sullivan
-</pre>
-<p>
-matches either "gilbert" or "sullivan". Any number of alternatives may
-appear, and an empty alternative is permitted (matching the empty
-string). The matching process tries each alternative in turn, from
-left to right, and the first one that succeeds is used. If the alternatives are within a subpattern (defined below), "succeeds" means matching the rest of the main pattern as well as the alternative in the subpattern.
-</p>
-</div>
-<div class="refsect1">
-<a name="id528063"></a><h2>Internal option setting</h2>
-<p>
-The settings of the <code class="varname">G_REGEX_CASELESS</code>, <code class="varname">G_REGEX_MULTILINE</code>, <code class="varname">G_REGEX_MULTILINE</code>,
-and <code class="varname">G_REGEX_EXTENDED</code> options can be changed from within the pattern by a
-sequence of Perl-style option letters enclosed between "(?" and ")". The
-option letters are
-</p>
-<div class="table">
-<a name="id528089"></a><p class="title"><b>Table 10. Option settings</b></p>
-<div class="table-contents"><table summary="Option settings" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Option</th>
-<th>Flag</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">i</td>
-<td><code class="varname">G_REGEX_CASELESS</code></td>
-</tr>
-<tr>
-<td align="center">m</td>
-<td><code class="varname">G_REGEX_MULTILINE</code></td>
-</tr>
-<tr>
-<td align="center">s</td>
-<td><code class="varname">G_REGEX_DOTALL</code></td>
-</tr>
-<tr>
-<td align="center">x</td>
-<td><code class="varname">G_REGEX_EXTENDED</code></td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-For example, (?im) sets caseless, multiline matching. It is also
-possible to unset these options by preceding the letter with a hyphen, and a
-combined setting and unsetting such as (?im-sx), which sets <code class="varname">G_REGEX_CASELESS</code>
-and <code class="varname">G_REGEX_MULTILINE</code> while unsetting <code class="varname">G_REGEX_DOTALL</code> and <code class="varname">G_REGEX_EXTENDED</code>,
-is also permitted. If a letter appears both before and after the
-hyphen, the option is unset.
-</p>
-<p>
-When an option change occurs at top level (that is, not inside subpattern
-parentheses), the change applies to the remainder of the pattern
-that follows.
-</p>
-<p>
-An option change within a subpattern (see below for a description of subpatterns)
-affects only that part of the current pattern that follows it, so
-</p>
-<pre class="programlisting">
-(a(?i)b)c
-</pre>
-<p>
-matches abc and aBc and no other strings (assuming <code class="varname">G_REGEX_CASELESS</code> is not
-used). By this means, options can be made to have different settings
-in different parts of the pattern. Any changes made in one alternative
-do carry on into subsequent branches within the same subpattern. For
-example,
-</p>
-<pre class="programlisting">
-(a(?i)b|c)
-</pre>
-<p>
-matches "ab", "aB", "c", and "C", even though when matching "C" the
-first branch is abandoned before the option setting. This is because
-the effects of option settings happen at compile time. There would be
-some very weird behaviour otherwise.
-</p>
-<p>
-The options <code class="varname">G_REGEX_UNGREEDY</code> and
-<code class="varname">G_REGEX_EXTRA</code> and <code class="varname">G_REGEX_DUPNAMES</code>
-can be changed in the same way as the Perl-compatible options by using
-the characters U, X and J respectively.
-</p>
-</div>
-<div class="refsect1">
-<a name="id528258"></a><h2>Subpatterns</h2>
-<p>
-Subpatterns are delimited by parentheses (round brackets), which can be
-nested. Turning part of a pattern into a subpattern does two things:
-</p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem"><p>
-It localizes a set of alternatives. For example, the pattern
-cat(aract|erpillar|) matches one of the words "cat", "cataract", or
-"caterpillar". Without the parentheses, it would match "cataract",
-"erpillar" or an empty string.
-</p></li>
-<li class="listitem"><p>
-It sets up the subpattern as a capturing subpattern. This means
-that, when the whole pattern matches, that portion of the
-string that matched the subpattern can be obtained using <code class="function">g_regex_fetch()</code>.
-Opening parentheses are counted from left to right (starting from 1, as
-subpattern 0 is the whole matched string) to obtain numbers for the
-capturing subpatterns.
-</p></li>
-</ul></div>
-<p>
-For example, if the string "the red king" is matched against the pattern
-</p>
-<pre class="programlisting">
-the ((red|white) (king|queen))
-</pre>
-<p>
-the captured substrings are "red king", "red", and "king", and are numbered 1, 2, and 3, respectively.
-</p>
-<p>
-The fact that plain parentheses fulfil two functions is not always
-helpful. There are often times when a grouping subpattern is required
-without a capturing requirement. If an opening parenthesis is followed
-by a question mark and a colon, the subpattern does not do any capturing,
-and is not counted when computing the number of any subsequent
-capturing subpatterns. For example, if the string "the white queen" is
-matched against the pattern
-</p>
-<pre class="programlisting">
-the ((?:red|white) (king|queen))
-</pre>
-<p>
-the captured substrings are "white queen" and "queen", and are numbered
-1 and 2. The maximum number of capturing subpatterns is 65535.
-</p>
-<p>
-As a convenient shorthand, if any option settings are required at the
-start of a non-capturing subpattern, the option letters may appear
-between the "?" and the ":". Thus the two patterns
-</p>
-<pre class="programlisting">
-(?i:saturday|sunday)
-(?:(?i)saturday|sunday)
-</pre>
-<p>
-match exactly the same set of strings. Because alternative branches are
-tried from left to right, and options are not reset until the end of
-the subpattern is reached, an option setting in one branch does affect
-subsequent branches, so the above patterns match "SUNDAY" as well as
-"Saturday".
-</p>
-</div>
-<div class="refsect1">
-<a name="id528344"></a><h2>Named subpatterns</h2>
-<p>
-Identifying capturing parentheses by number is simple, but it can be
-very hard to keep track of the numbers in complicated regular expressions.
-Furthermore, if an expression is modified, the numbers may
-change. To help with this difficulty, GRegex supports the naming of
-subpatterns.  A subpattern can be named in one of three ways: (?&lt;name&gt;...) or
-(?'name'...) as in Perl, or (?P&lt;name&gt;...) as in Python.
-References to capturing parentheses from other
-parts of the pattern, such as backreferences, recursion, and conditions,
-can be made by name as well as by number.
-</p>
-<p>
-Names consist of up to 32 alphanumeric characters and underscores. Named
-capturing parentheses are still allocated numbers as well as names, exactly as
-if the names were not present.
-By default, a name must be unique within a pattern, but it is possible to relax
-this constraint by setting the <code class="varname">G_REGEX_DUPNAMES</code> option at
-compile time. This can be useful for patterns where only one instance of the
-named parentheses can match. Suppose you want to match the name of a weekday,
-either as a 3-letter abbreviation or as the full name, and in both cases you
-want to extract the abbreviation. This pattern (ignoring the line breaks) does
-the job:
-</p>
-<pre class="programlisting">
-(?&lt;DN&gt;Mon|Fri|Sun)(?:day)?|
-(?&lt;DN&gt;Tue)(?:sday)?|
-(?&lt;DN&gt;Wed)(?:nesday)?|
-(?&lt;DN&gt;Thu)(?:rsday)?|
-(?&lt;DN&gt;Sat)(?:urday)?
-</pre>
-<p>
-There are five capturing substrings, but only one is ever set after a match.
-The function for extracting the data by name returns the substring
-for the first (and in this example, the only) subpattern of that name that
-matched. This saves searching to find which numbered subpattern it was. If you
-make a reference to a non-unique named subpattern from elsewhere in the
-pattern, the one that corresponds to the lowest number is used.
-</p>
-</div>
-<div class="refsect1">
-<a name="id528386"></a><h2>Repetition</h2>
-<p>
-Repetition is specified by quantifiers, which can follow any of the
-following items:
-</p>
-<div class="itemizedlist"><ul class="itemizedlist" type="disc">
-<li class="listitem"><p>a literal data character</p></li>
-<li class="listitem"><p>the dot metacharacter</p></li>
-<li class="listitem"><p>the \C escape sequence</p></li>
-<li class="listitem"><p>the \X escape sequence (in UTF-8 mode)</p></li>
-<li class="listitem"><p>the \R escape sequence</p></li>
-<li class="listitem"><p>an escape such as \d that matches a single character</p></li>
-<li class="listitem"><p>a character class</p></li>
-<li class="listitem"><p>a back reference (see next section)</p></li>
-<li class="listitem"><p>a parenthesized subpattern (unless it is an assertion)</p></li>
-</ul></div>
-<p>
-The general repetition quantifier specifies a minimum and maximum number
-of permitted matches, by giving the two numbers in curly brackets
-(braces), separated by a comma. The numbers must be less than 65536,
-and the first must be less than or equal to the second. For example:
-</p>
-<pre class="programlisting">
-z{2,4}
-</pre>
-<p>
-matches "zz", "zzz", or "zzzz". A closing brace on its own is not a
-special character. If the second number is omitted, but the comma is
-present, there is no upper limit; if the second number and the comma
-are both omitted, the quantifier specifies an exact number of required
-matches. Thus
-</p>
-<pre class="programlisting">
-[aeiou]{3,}
-</pre>
-<p>
-matches at least 3 successive vowels, but may match many more, while
-</p>
-<pre class="programlisting">
-\d{8}
-</pre>
-<p>
-matches exactly 8 digits. An opening curly bracket that appears in a
-position where a quantifier is not allowed, or one that does not match
-the syntax of a quantifier, is taken as a literal character. For example,
-{,6} is not a quantifier, but a literal string of four characters.
-</p>
-<p>
-In UTF-8 mode, quantifiers apply to UTF-8 characters rather than to
-individual bytes. Thus, for example, \x{100}{2} matches two UTF-8
-characters, each of which is represented by a two-byte sequence. Similarly,
-\X{3} matches three Unicode extended sequences, each of which may be
-several bytes long (and they may be of different lengths).
-</p>
-<p>
-The quantifier {0} is permitted, causing the expression to behave as if
-the previous item and the quantifier were not present.
-</p>
-<p>
-For convenience, the three most common quantifiers have single-character
-abbreviations:
-</p>
-<div class="table">
-<a name="id528498"></a><p class="title"><b>Table 11. Abbreviations for quantifiers</b></p>
-<div class="table-contents"><table summary="Abbreviations for quantifiers" border="1">
-<colgroup>
-<col align="center">
-<col>
-</colgroup>
-<thead><tr>
-<th align="center">Abbreviation</th>
-<th>Meaning</th>
-</tr></thead>
-<tbody>
-<tr>
-<td align="center">*</td>
-<td>is equivalent to {0,}</td>
-</tr>
-<tr>
-<td align="center">+</td>
-<td>is equivalent to {1,}</td>
-</tr>
-<tr>
-<td align="center">?</td>
-<td>is equivalent to {0,1}</td>
-</tr>
-</tbody>
-</table></div>
-</div>
-<br class="table-break"><p>
-It is possible to construct infinite loops by following a subpattern
-that can match no characters with a quantifier that has no upper limit,
-for example:
-</p>
-<pre class="programlisting">
-(a?)*
-</pre>
-<p>
-Because there are cases where this can be useful, such patterns are
-accepted, but if any repetition of the subpattern does in fact match
-no characters, the loop is forcibly broken.
-</p>
-<p>
-By default, the quantifiers are "greedy", that is, they match as much
-as possible (up to the maximum number of permitted times), without
-causing the rest of the pattern to fail. The classic example of where
-this gives problems is in trying to match comments in C programs. These
-appear between /* and */ and within the comment, individual * and /
-characters may appear. An attempt to match C comments by applying the
-pattern
-</p>
-<pre class="programlisting">
-/\*.*\*/
-</pre>
-<p>
-to the string
-</p>
-<pre class="programlisting">
-/* first comment */  not comment  /* second comment */
-</pre>
-<p>
-fails, because it matches the entire string owing to the greediness of
-the .* item.
-</p>
-<p>
-However, if a quantifier is followed by a question mark, it ceases to
-be greedy, and instead matches the minimum number of times possible, so
-the pattern
-</p>
-<pre class="programlisting">
-/\*.*?\*/
-</pre>
-<p>
-does the right thing with the C comments. The meaning of the various
-quantifiers is not otherwise changed, just the preferred number of
-matches. Do not confuse this use of question mark with its use as a
-quantifier in its own right. Because it has two uses, it can sometimes
-appear doubled, as in
-</p>
-<pre class="programlisting">
-\d??\d
-</pre>
-<p>
-which matches one digit by preference, but can match two if that is the
-only way the rest of the pattern matches.
-</p>
-<p>
-If the <code class="varname">G_REGEX_UNGREEDY</code> flag is set, the quantifiers are not greedy
-by default, but individual ones can be made greedy by following them with
-a question mark. In other words, it inverts the default behaviour.
-</p>
-<p>
-When a parenthesized subpattern is quantified with a minimum repeat
-count that is greater than 1 or with a limited maximum, more memory is
-required for the compiled pattern, in proportion to the size of the
-minimum or maximum.
-</p>
-<p>
-If a pattern starts with .* or .{0,} and the <code class="varname">G_REGEX_DOTALL</code> flag
-is set, thus allowing the dot to match newlines, the
-pattern is implicitly anchored, because whatever follows will be tried
-against every character position in the string, so there is no
-point in retrying the overall match at any position after the first.
-GRegex normally treats such a pattern as though it were preceded by \A.
-</p>
-<p>
-In cases where it is known that the string contains no newlines, it
-is worth setting <code class="varname">G_REGEX_DOTALL</code> in order to obtain this optimization,
-or alternatively using ^ to indicate anchoring explicitly.
-</p>
-<p>
-However, there is one situation where the optimization cannot be used.
-When .* is inside capturing parentheses that are the subject of a
-backreference elsewhere in the pattern, a match at the start may fail
-where a later one succeeds. Consider, for example:
-</p>
-<pre class="programlisting">
-(.*)abc\1
-</pre>
-<p>
-If the string is "xyz123abc123" the match point is the fourth character.
-For this reason, such a pattern is not implicitly anchored.
-</p>
-<p>
-When a capturing subpattern is repeated, the value captured is the
-substring that matched the final iteration. For example, after
-</p>
-<pre class="programlisting">
-(tweedle[dume]{3}\s*)+
-</pre>
-<p>
-has matched "tweedledum tweedledee" the value of the captured substring
-is "tweedledee". However, if there are nested capturing subpatterns,
-the corresponding captured values may have been set in previous iterations.
-For example, after
-</p>
-<pre class="programlisting">
-/(a|(b))+/
-</pre>
-<p>
-matches "aba" the value of the second captured substring is "b".
-</p>
-</div>
-<div class="refsect1">
-<a name="id574453"></a><h2>Atomic grouping and possessive quantifiers</h2>
-<p>
-With both maximizing ("greedy") and minimizing ("ungreedy" or "lazy")
-repetition, failure of what follows normally causes the repeated
-item to be re-evaluated to see if a different number
-of repeats allows the rest of the pattern to match. Sometimes it
-is useful to prevent this, either to change the nature of the
-match, or to cause it fail earlier than it otherwise might, when the
-author of the pattern knows there is no point in carrying on.
-</p>
-<p>
-Consider, for example, the pattern \d+foo when applied to the string
-</p>
-<pre class="programlisting">
-123456bar
-</pre>
-<p>
-After matching all 6 digits and then failing to match "foo", the normal
-action of the matcher is to try again with only 5 digits matching the
-\d+ item, and then with 4, and so on, before ultimately failing.
-"Atomic grouping" (a term taken from Jeffrey Friedl’s book) provides
-the means for specifying that once a subpattern has matched, it is not
-to be re-evaluated in this way.
-</p>
-<p>
-If we use atomic grouping for the previous example, the matcher
-give up immediately on failing to match "foo" the first time. The notation
-is a kind of special parenthesis, starting with (?&gt; as in this
-example:
-</p>
-<pre class="programlisting">
-(?&gt;\d+)foo
-</pre>
-<p>
-This kind of parenthesis "locks up" the part of the pattern it contains
-once it has matched, and a failure further into the pattern is
-prevented from backtracking into it. Backtracking past it to previous
-items, however, works as normal.
-</p>
-<p>
-An alternative description is that a subpattern of this type matches
-the string of characters that an identical standalone pattern would
-match, if anchored at the current point in the string.
-</p>
-<p>
-Atomic grouping subpatterns are not capturing subpatterns. Simple cases
-such as the above example can be thought of as a maximizing repeat that
-must swallow everything it can. So, while both \d+ and \d+? are prepared
-to adjust the number of digits they match in order to make the
-rest of the pattern match, (?&gt;\d+) can only match an entire sequence of
-digits.
-</p>
-<p>
-Atomic groups in general can of course contain arbitrarily complicated
-subpatterns, and can be nested. However, when the subpattern for an
-atomic group is just a single repeated item, as in the example above, a
-simpler notation, called a "possessive quantifier" can be used. This
-consists of an additional + character following a quantifier. Using
-this notation, the previous example can be rewritten as
-</p>
-<pre class="programlisting">
-\d++foo
-</pre>
-<p>
-Possessive quantifiers are always greedy; the setting of the
-<code class="varname">G_REGEX_UNGREEDY</code> option is ignored. They are a convenient notation for the
-simpler forms of atomic group. However, there is no difference in the
-meaning of a possessive quantifier and the equivalent
-atomic group, though there may be a performance difference;
-possessive quantifiers should be slightly faster.
-</p>
-<p>
-The possessive quantifier syntax is an extension to the Perl syntax.
-It was invented by Jeffrey Friedl in the first edition of his book and
-then implemented by Mike McCloskey in Sun's Java package.
-It ultimately found its way into Perl at release 5.10.
-</p>
-<p>
-GRegex has an optimization that automatically "possessifies" certain simple
-pattern constructs. For example, the sequence A+B is treated as A++B because
-there is no point in backtracking into a sequence of A's when B must follow.
-</p>
-<p>
-When a pattern contains an unlimited repeat inside a subpattern that
-can itself be repeated an unlimited number of times, the use of an
-atomic group is the only way to avoid some failing matches taking a
-very long time indeed. The pattern
-</p>
-<pre class="programlisting">
-(\D+|&lt;\d+&gt;)*[!?]
-</pre>
-<p>
-matches an unlimited number of substrings that either consist of non-
-digits, or digits enclosed in &lt;&gt;, followed by either ! or ?. When it
-matches, it runs quickly. However, if it is applied to
-</p>
-<pre class="programlisting">
-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
-</pre>
-<p>
-it takes a long time before reporting failure. This is because the
-string can be divided between the internal \D+ repeat and the external
-* repeat in a large number of ways, and all have to be tried. (The
-example uses [!?] rather than a single character at the end, because
-GRegex has an optimization that allows for fast failure
-when a single character is used. It remember the last single character
-that is required for a match, and fail early if it is not present
-in the string.) If the pattern is changed so that it uses an atomic
-group, like this:
-</p>
-<pre class="programlisting">
-((?&gt;\D+)|&lt;\d+&gt;)*[!?]
-</pre>
-<p>
-sequences of non-digits cannot be broken, and failure happens quickly.
-</p>
-</div>
-<div class="refsect1">
-<a name="id574588"></a><h2>Back references</h2>
-<p>
-Outside a character class, a backslash followed by a digit greater than
-0 (and possibly further digits) is a back reference to a capturing subpattern
-earlier (that is, to its left) in the pattern, provided there have been that
-many previous capturing left parentheses.
-</p>
-<p>
-However, if the decimal number following the backslash is less than 10,
-it is always taken as a back reference, and causes an error only if
-there are not that many capturing left parentheses in the entire pattern.
-In other words, the parentheses that are referenced need not be
-to the left of the reference for numbers less than 10. A "forward back
-reference" of this type can make sense when a repetition is involved and
-the subpattern to the right has participated in an earlier iteration.
-</p>
-<p>
-It is not possible to have a numerical "forward back reference" to subpattern
-whose number is 10 or more using this syntax because a sequence such as \e50 is
-interpreted as a character defined in octal. See the subsection entitled
-"Non-printing characters" above for further details of the handling of digits
-following a backslash. There is no such problem when named parentheses are used.
-A back reference to any subpattern is possible using named parentheses (see below).
-</p>
-<p>
-Another way of avoiding the ambiguity inherent in the use of digits following a
-backslash is to use the \g escape sequence (introduced in Perl 5.10.)
-This escape must be followed by a positive or a negative number,
-optionally enclosed in braces.
-</p>
-<p>
-A positive number specifies an absolute reference without the ambiguity that is
-present in the older syntax. It is also useful when literal digits follow the
-reference. A negative number is a relative reference. Consider "(abc(def)ghi)\g{-1}",
-the sequence \g{-1} is a reference to the most recently started capturing
-subpattern before \g, that is, is it equivalent to \2. Similarly, \g{-2}
-would be equivalent to \1. The use of relative references can be helpful in
-long patterns, and also in patterns that are created by joining together
-fragments that contain references within themselves.
-</p>
-<p>
-A back reference matches whatever actually matched the capturing subpattern
-in the current string, rather than anything matching
-the subpattern itself (see "Subpatterns as subroutines" below for a way
-of doing that). So the pattern
-</p>
-<pre class="programlisting">
-(sens|respons)e and \1ibility
-</pre>
-<p>
-matches "sense and sensibility" and "response and responsibility", but
-not "sense and responsibility". If caseful matching is in force at the
-time of the back reference, the case of letters is relevant. For example,
-</p>
-<pre class="programlisting">
-((?i)rah)\s+\1
-</pre>
-<p>
-matches "rah rah" and "RAH RAH", but not "RAH rah", even though the
-original capturing subpattern is matched caselessly.
-</p>
-<p>
-Back references to named subpatterns use the Perl syntax \k&lt;name&gt; or \k'name'
-or the Python syntax (?P=name). We could rewrite the above example in either of
-the following ways:
-</p>
-<pre class="programlisting">
-(?&lt;p1&gt;(?i)rah)\s+\k&lt;p1&gt;
-(?P&lt;p1&gt;(?i)rah)\s+(?P=p1)
-</pre>
-<p>
-A subpattern that is referenced by name may appear in the pattern before or
-after the reference.
-</p>
-<p>
-There may be more than one back reference to the same subpattern. If a
-subpattern has not actually been used in a particular match, any back
-references to it always fail. For example, the pattern
-</p>
-<pre class="programlisting">
-(a|(bc))\2
-</pre>
-<p>
-always fails if it starts to match "a" rather than "bc". Because there
-may be many capturing parentheses in a pattern, all digits following
-the backslash are taken as part of a potential back reference number.
-If the pattern continues with a digit character, some delimiter must be
-used to terminate the back reference. If the <code class="varname">G_REGEX_EXTENDED</code> flag is
-set, this can be whitespace. Otherwise an empty comment (see "Comments" below) can be used.
-</p>
-<p>
-A back reference that occurs inside the parentheses to which it refers
-fails when the subpattern is first used, so, for example, (a\1) never
-matches. However, such references can be useful inside repeated subpatterns.
-For example, the pattern
-</p>
-<pre class="programlisting">
-(a|b\1)+
-</pre>
-<p>
-matches any number of "a"s and also "aba", "ababbaa" etc. At each iteration
-of the subpattern, the back reference matches the character
-string corresponding to the previous iteration. In order for this to
-work, the pattern must be such that the first iteration does not need
-to match the back reference. This can be done using alternation, as in
-the example above, or by a quantifier with a minimum of zero.
-</p>
-</div>
-<div class="refsect1">
-<a name="id574715"></a><h2>Assertions</h2>
-<p>
-An assertion is a test on the characters following or preceding the
-current matching point that does not actually consume any characters.
-The simple assertions coded as \b, \B, \A, \G, \Z, \z, ^ and $ are
-described above.
-</p>
-<p>
-More complicated assertions are coded as subpatterns. There are two
-kinds: those that look ahead of the current position in the
-string, and those that look behind it. An assertion subpattern is
-matched in the normal way, except that it does not cause the current
-matching position to be changed.
-</p>
-<p>
-Assertion subpatterns are not capturing subpatterns, and may not be
-repeated, because it makes no sense to assert the same thing several
-times. If any kind of assertion contains capturing subpatterns within
-it, these are counted for the purposes of numbering the capturing
-subpatterns in the whole pattern. However, substring capturing is carried
-out only for positive assertions, because it does not make sense for
-negative assertions.
-</p>
-<div class="refsect2">
-<a name="id574740"></a><h3>Lookahead assertions</h3>
-<p>
-Lookahead assertions start with (?= for positive assertions and (?! for
-negative assertions. For example,
-</p>
-<pre class="programlisting">
-\w+(?=;)
-</pre>
-<p>
-matches a word followed by a semicolon, but does not include the semicolon
-in the match, and
-</p>
-<pre class="programlisting">
-foo(?!bar)
-</pre>
-<p>
-matches any occurrence of "foo" that is not followed by "bar". Note
-that the apparently similar pattern
-</p>
-<pre class="programlisting">
-(?!foo)bar
-</pre>
-<p>
-does not find an occurrence of "bar" that is preceded by something
-other than "foo"; it finds any occurrence of "bar" whatsoever, because
-the assertion (?!foo) is always true when the next three characters are
-"bar". A lookbehind assertion is needed to achieve the other effect.
-</p>
-<p>
-If you want to force a matching failure at some point in a pattern, the
-most convenient way to do it is with (?!) because an empty string
-always matches, so an assertion that requires there not to be an empty
-string must always fail.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id574790"></a><h3>Lookbehind assertions</h3>
-<p>
-Lookbehind assertions start with (?&lt;= for positive assertions and (?&lt;!
-for negative assertions. For example,
-</p>
-<pre class="programlisting">
-(?&lt;!foo)bar
-</pre>
-<p>
-does find an occurrence of "bar" that is not preceded by "foo". The
-contents of a lookbehind assertion are restricted such that all the
-strings it matches must have a fixed length. However, if there are
-several top-level alternatives, they do not all have to have the same
-fixed length. Thus
-</p>
-<pre class="programlisting">
-(?&lt;=bullock|donkey)
-</pre>
-<p>
-is permitted, but
-</p>
-<pre class="programlisting">
-(?&lt;!dogs?|cats?)
-</pre>
-<p>
-causes an error at compile time. Branches that match different length
-strings are permitted only at the top level of a lookbehind assertion.
-An assertion such as
-</p>
-<pre class="programlisting">
-(?&lt;=ab(c|de))
-</pre>
-<p>
-is not permitted, because its single top-level branch can match two
-different lengths, but it is acceptable if rewritten to use two top-
-level branches:
-</p>
-<pre class="programlisting">
-(?&lt;=abc|abde)
-</pre>
-<p>
-The implementation of lookbehind assertions is, for each alternative,
-to temporarily move the current position back by the fixed length and
-then try to match. If there are insufficient characters before the
-current position, the assertion fails.
-</p>
-<p>
-GRegex does not allow the \C escape (which matches a single byte in UTF-8
-mode) to appear in lookbehind assertions, because it makes it impossible
-to calculate the length of the lookbehind. The \X and \R escapes, which can
-match different numbers of bytes, are also not permitted.
-</p>
-<p>
-Possessive quantifiers can be used in conjunction with lookbehind assertions to
-specify efficient matching at the end of the subject string. Consider a simple
-pattern such as
-</p>
-<pre class="programlisting">
-abcd$
-</pre>
-<p>
-when applied to a long string that does not match. Because matching
-proceeds from left to right, GRegex will look for each "a" in the string
-and then see if what follows matches the rest of the pattern. If the
-pattern is specified as
-</p>
-<pre class="programlisting">
-^.*abcd$
-</pre>
-<p>
-the initial .* matches the entire string at first, but when this fails
-(because there is no following "a"), it backtracks to match all but the
-last character, then all but the last two characters, and so on. Once
-again the search for "a" covers the entire string, from right to left,
-so we are no better off. However, if the pattern is written as
-</p>
-<pre class="programlisting">
-^.*+(?&lt;=abcd)
-</pre>
-<p>
-there can be no backtracking for the .*+ item; it can match only the
-entire string. The subsequent lookbehind assertion does a single test
-on the last four characters. If it fails, the match fails immediately.
-For long strings, this approach makes a significant difference to the
-processing time.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id574905"></a><h3>Using multiple assertions</h3>
-<p>
-Several assertions (of any sort) may occur in succession. For example,
-</p>
-<pre class="programlisting">
-(?&lt;=\d{3})(?&lt;!999)foo
-</pre>
-<p>
-matches "foo" preceded by three digits that are not "999". Notice that
-each of the assertions is applied independently at the same point in
-the string. First there is a check that the previous three
-characters are all digits, and then there is a check that the same
-three characters are not "999". This pattern does not match "foo" preceded
-by six characters, the first of which are digits and the last
-three of which are not "999". For example, it doesn’t match "123abcfoo".
-A pattern to do that is
-</p>
-<pre class="programlisting">
-(?&lt;=\d{3}...)(?&lt;!999)foo
-</pre>
-<p>
-This time the first assertion looks at the preceding six characters,
-checking that the first three are digits, and then the second assertion
-checks that the preceding three characters are not "999".
-</p>
-<p>
-Assertions can be nested in any combination. For example,
-</p>
-<pre class="programlisting">
-(?&lt;=(?&lt;!foo)bar)baz
-</pre>
-<p>
-matches an occurrence of "baz" that is preceded by "bar" which in turn
-is not preceded by "foo", while
-</p>
-<pre class="programlisting">
-(?&lt;=\d{3}(?!999)...)foo
-</pre>
-<p>
-is another pattern that matches "foo" preceded by three digits and any
-three characters that are not "999".
-</p>
-</div>
-</div>
-<div class="refsect1">
-<a name="id574968"></a><h2>Conditional subpatterns</h2>
-<p>
-It is possible to cause the matching process to obey a subpattern
-conditionally or to choose between two alternative subpatterns, depending
-on the result of an assertion, or whether a previous capturing subpattern
-matched or not. The two possible forms of conditional subpattern are
-</p>
-<pre class="programlisting">
-(?(condition)yes-pattern)
-(?(condition)yes-pattern|no-pattern)
-</pre>
-<p>
-If the condition is satisfied, the yes-pattern is used; otherwise the
-no-pattern (if present) is used. If there are more than two alternatives
-in the subpattern, a compile-time error occurs.
-</p>
-<p>
-There are four kinds of condition: references to subpatterns, references to
-recursion, a pseudo-condition called DEFINE, and assertions.
-</p>
-<div class="refsect2">
-<a name="id574997"></a><h3>Checking for a used subpattern by number</h3>
-<p>
-If the text between the parentheses consists of a sequence of digits, the
-condition is true if the capturing subpattern of that number has previously
-matched.
-</p>
-<p>
-Consider the following pattern, which contains non-significant white space
-to make it more readable (assume the <code class="varname">G_REGEX_EXTENDED</code>)
-and to divide it into three parts for ease of discussion:
-</p>
-<pre class="programlisting">
-( \( )?    [^()]+    (?(1) \) )
-</pre>
-<p>
-The first part matches an optional opening parenthesis, and if that
-character is present, sets it as the first captured substring. The second
-part matches one or more characters that are not parentheses. The
-third part is a conditional subpattern that tests whether the first set
-of parentheses matched or not. If they did, that is, if string started
-with an opening parenthesis, the condition is true, and so the yes-pattern
-is executed and a closing parenthesis is required. Otherwise,
-since no-pattern is not present, the subpattern matches nothing. In
-other words, this pattern matches a sequence of non-parentheses,
-optionally enclosed in parentheses.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id575033"></a><h3>Checking for a used subpattern by name</h3>
-<p>
-Perl uses the syntax (?(&lt;name&gt;)...) or (?('name')...) to test for a used
-subpattern by name, the Python syntax (?(name)...) is also recognized. However,
-there is a possible ambiguity with this syntax, because subpattern names may
-consist entirely of digits. GRegex looks first for a named subpattern; if it
-cannot find one and the name consists entirely of digits, GRegex looks for a
-subpattern of that number, which must be greater than zero. Using subpattern
-names that consist entirely of digits is not recommended.
-</p>
-<p>
-Rewriting the above example to use a named subpattern gives this:
-</p>
-<pre class="programlisting">
-(?&lt;OPEN&gt; \( )?    [^()]+    (?(&lt;OPEN&gt;) \) )
-</pre>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id575058"></a><h3>Checking for pattern recursion</h3>
-<p>
-If the condition is the string (R), and there is no subpattern with the name R,
-the condition is true if a recursive call to the whole pattern or any
-subpattern has been made. If digits or a name preceded by ampersand follow the
-letter R, for example:
-</p>
-<pre class="programlisting">
-(?(R3)...)
-(?(R&amp;name)...)
-</pre>
-<p>
-the condition is true if the most recent recursion is into the subpattern whose
-number or name is given. This condition does not check the entire recursion
-stack.
-</p>
-<p>
-At "top level", all these recursion test conditions are false. Recursive
-patterns are described below.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id575087"></a><h3>Defining subpatterns for use by reference only</h3>
-<p>
-If the condition is the string (DEFINE), and there is no subpattern with the
-name DEFINE, the condition is always false. In this case, there may be only one
-alternative in the subpattern. It is always skipped if control reaches this
-point in the pattern; the idea of DEFINE is that it can be used to define
-"subroutines" that can be referenced from elsewhere. (The use of "subroutines"
-is described below.) For example, a pattern to match an IPv4 address could be
-written like this (ignore whitespace and line breaks):
-</p>
-<pre class="programlisting">
-(?(DEFINE) (?&lt;byte&gt; 2[0-4]\d | 25[0-5] | 1\d\d | [1-9]?\d) )
-\b (?&amp;byte) (\.(?&amp;byte)){3} \b
-</pre>
-<p>
-The first part of the pattern is a DEFINE group inside which a another group
-named "byte" is defined. This matches an individual component of an IPv4
-address (a number less than 256). When matching takes place, this part of the
-pattern is skipped because DEFINE acts like a false condition.
-</p>
-<p>
-The rest of the pattern uses references to the named group to match the four
-dot-separated components of an IPv4 address, insisting on a word boundary at
-each end.
-</p>
-</div>
-<hr>
-<div class="refsect2">
-<a name="id575120"></a><h3>Assertion conditions</h3>
-<p>
-If the condition is not in any of the above formats, it must be an
-assertion. This may be a positive or negative lookahead or lookbehind
-assertion. Consider this pattern, again containing non-significant
-white space, and with the two alternatives on the second line:
-</p>
-<pre class="programlisting">
-(?(?=[^a-z]*[a-z])
-\d{2}-[a-z]{3}-\d{2}  |  \d{2}-\d{2}-\d{2} )
-</pre>
-<p>
-The condition is a positive lookahead assertion that matches an
-optional sequence of non-letters followed by a letter. In other words,
-it tests for the presence of at least one letter in the string. If a
-letter is found, the string is matched against the first alternative;
-otherwise it is matched against the second. This pattern matches
-strings in one of the two forms dd-aaa-dd or dd-dd-dd, where aaa are
-letters and dd are digits.
-</p>
-</div>
-</div>
-<div class="refsect1">
-<a name="id575148"></a><h2>Comments</h2>
-<p>
-The sequence (?# marks the start of a comment that continues up to the
-next closing parenthesis. Nested parentheses are not permitted. The
-characters that make up a comment play no part in the pattern matching
-at all.
-</p>
-<p>
-If the <code class="varname">G_REGEX_EXTENDED</code> option is set, an unescaped #
-character outside a character class introduces a comment that continues to
-immediately after the next newline in the pattern.
-</p>
-</div>
-<div class="refsect1">
-<a name="id575170"></a><h2>Recursive patterns</h2>
-<p>
-Consider the problem of matching a string in parentheses, allowing for
-unlimited nested parentheses. Without the use of recursion, the best
-that can be done is to use a pattern that matches up to some fixed
-depth of nesting. It is not possible to handle an arbitrary nesting
-depth.
-</p>
-<p>
-For some time, Perl has provided a facility that allows regular expressions to
-recurse (amongst other things). It does this by interpolating Perl code in the
-expression at run time, and the code can refer to the expression itself. A Perl
-pattern using code interpolation to solve the parentheses problem can be
-created like this:
-</p>
-<pre class="programlisting">
-$re = qr{\( (?: (?&gt;[^()]+) | (?p{$re}) )* \)}x;
-</pre>
-<p>
-The (?p{...}) item interpolates Perl code at run time, and in this case refers
-recursively to the pattern in which it appears.
-</p>
-<p>
-Obviously, GRegex cannot support the interpolation of Perl code. Instead, it
-supports special syntax for recursion of the entire pattern, and also for
-individual subpattern recursion. This kind of recursion was introduced into
-Perl at release 5.10.
-</p>
-<p>
-A special item that consists of (? followed by a number greater than zero and a
-closing parenthesis is a recursive call of the subpattern of the given number,
-provided that it occurs inside that subpattern. (If not, it is a "subroutine"
-call, which is described in the next section.) The special item (?R) or (?0) is
-a recursive call of the entire regular expression.
-</p>
-<p>
-In GRegex (like Python, but unlike Perl), a recursive subpattern call is always
-treated as an atomic group. That is, once it has matched some of the subject
-string, it is never re-entered, even if it contains untried alternatives and
-there is a subsequent matching failure.
-</p>
-<p>
-This pattern solves the nested parentheses problem (assume the
-<code class="varname">G_REGEX_EXTENDED</code> option is set so that white space is
-ignored):
-</p>
-<pre class="programlisting">
-\( ( (?&gt;[^()]+) | (?R) )* \)
-</pre>
-<p>
-First it matches an opening parenthesis. Then it matches any number of
-substrings which can either be a sequence of non-parentheses, or a
-recursive match of the pattern itself (that is, a correctly parenthesized
-substring). Finally there is a closing parenthesis.
-</p>
-<p>
-If this were part of a larger pattern, you would not want to recurse
-the entire pattern, so instead you could use this:
-</p>
-<pre class="programlisting">
-( \( ( (?&gt;[^()]+) | (?1) )* \) )
-</pre>
-<p>
-We have put the pattern into parentheses, and caused the recursion to
-refer to them instead of the whole pattern. In a larger pattern, keeping
-track of parenthesis numbers can be tricky. It may be more convenient to
-use named parentheses instead.
-The Perl syntax for this is (?&amp;name); GRegex also supports the(?P&gt;name)
-syntac. We could rewrite the above example as follows:
-</p>
-<pre class="programlisting">
-(?&lt;pn&gt; \( ( (?&gt;[^()]+) | (?&amp;pn) )* \) )
-</pre>
-<p>
-If there is more than one subpattern with the same name, the earliest one is
-used. This particular example pattern contains nested unlimited repeats, and so
-the use of atomic grouping for matching strings of non-parentheses is important
-when applying the pattern to strings that do not match.
-For example, when this pattern is applied to
-</p>
-<pre class="programlisting">
-(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()
-</pre>
-<p>
-it yields "no match" quickly. However, if atomic grouping is not used,
-the match runs for a very long time indeed because there are so many
-different ways the + and * repeats can carve up the string, and all
-have to be tested before failure can be reported.
-</p>
-<p>
-At the end of a match, the values set for any capturing subpatterns are
-those from the outermost level of the recursion at which the subpattern
-value is set.
-If the pattern above is matched against
-</p>
-<pre class="programlisting">
-(ab(cd)ef)
-</pre>
-<p>
-the value for the capturing parentheses is "ef", which is the last
-value taken on at the top level. If additional parentheses are added,
-giving
-</p>
-<pre class="programlisting">
-\( ( ( (?&gt;[^()]+) | (?R) )* ) \)
-   ^                        ^
-   ^                        ^
-</pre>
-<p>
-the string they capture is "ab(cd)ef", the contents of the top level
-parentheses.
-</p>
-<p>
-Do not confuse the (?R) item with the condition (R), which tests for
-recursion. Consider this pattern, which matches text in angle brackets,
-allowing for arbitrary nesting. Only digits are allowed in nested
-brackets (that is, when recursing), whereas any characters are permitted
-at the outer level.
-</p>
-<pre class="programlisting">
-&lt; (?: (?(R) \d++ | [^&lt;&gt;]*+) | (?R)) * &gt;
-</pre>
-<p>
-In this pattern, (?(R) is the start of a conditional subpattern, with
-two different alternatives for the recursive and non-recursive cases.
-The (?R) item is the actual recursive call.
-</p>
-</div>
-<div class="refsect1">
-<a name="id575327"></a><h2>Subpatterns as subroutines</h2>
-<p>
-If the syntax for a recursive subpattern reference (either by number or
-by name) is used outside the parentheses to which it refers, it operates
-like a subroutine in a programming language. The "called" subpattern may
-be defined before or after the reference. An earlier example pointed out
-that the pattern
-</p>
-<pre class="programlisting">
-(sens|respons)e and \1ibility
-</pre>
-<p>
-matches "sense and sensibility" and "response and responsibility", but
-not "sense and responsibility". If instead the pattern
-</p>
-<pre class="programlisting">
-(sens|respons)e and (?1)ibility
-</pre>
-<p>
-is used, it does match "sense and responsibility" as well as the other
-two strings. Another example is given in the discussion of DEFINE above.
-</p>
-<p>
-Like recursive subpatterns, a "subroutine" call is always treated as an atomic
-group. That is, once it has matched some of the string, it is never
-re-entered, even if it contains untried alternatives and there is a subsequent
-matching failure.
-</p>
-<p>
-When a subpattern is used as a subroutine, processing options such as
-case-independence are fixed when the subpattern is defined. They cannot be
-changed for different calls. For example, consider this pattern:
-</p>
-<pre class="programlisting">
-(abc)(?i:(?1))
-</pre>
-<p>
-It matches "abcabc". It does not match "abcABC" because the change of
-processing option does not affect the called subpattern.
-</p>
-</div>
-<div class="refsect1">
-<a name="id575401"></a><h2>Copyright</h2>
-<p>
-This document was copied and adapted from the PCRE documentation,
-specifically from the man page for pcrepattern.
-The original copyright note is:
-</p>
-<pre class="programlisting">
-Copyright (c) 1997-2006 University of Cambridge.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the University of Cambridge nor the name of Google
-      Inc. nor the names of their contributors may be used to endorse or
-      promote products derived from this software without specific prior
-      written permission.
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-</pre>
-</div>
-</div>
-<div class="footer">
-<hr>
-          Generated by GTK-Doc V1.15.1</div>
-</body>
-</html>