RubyGems - glib2 - Versions diffs - 1.1.8-x86-mingw32 → 1.1.9-x86-mingw32 - Mend

glib2 1.1.8-x86-mingw32 → 1.1.9-x86-mingw32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1810) hide show

data/vendor/local/share/gtk-doc/html/glib/glib-Memory-Slices.html CHANGED

@@ -3,22 +3,22 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Memory Slices</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <link rel="home" href="index.html" title="GLib Reference Manual">
-<link rel="up" href="glib-data-types.html" title="GLib Data Types">
-<link rel="prev" href="glib-data-types.html" title="GLib Data Types">
-<link rel="next" href="glib-Memory-Chunks.html" title="Memory Chunks">
-<meta name="generator" content="GTK-Doc V1.17 (XML mode)">
+<link rel="up" href="glib-core.html" title="GLib Core Application Support">
+<link rel="prev" href="glib-Memory-Allocation.html" title="Memory Allocation">
+<link rel="next" href="glib-IO-Channels.html" title="IO Channels">
+<meta name="generator" content="GTK-Doc V1.18 (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-data-types.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
-<td><a accesskey="u" href="glib-data-types.html"><img src="up.png" width="24" height="24" border="0" alt="Up"></a></td>
+<td><a accesskey="p" href="glib-Memory-Allocation.html"><img src="left.png" width="24" height="24" border="0" alt="Prev"></a></td>
+<td><a accesskey="u" href="glib-core.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-Memory-Chunks.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+<td><a accesskey="n" href="glib-IO-Channels.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
 </tr>
 <tr><td colspan="5" class="shortcuts">
 <a href="#glib-Memory-Slices.synopsis" class="shortcut">Top</a>
@@ -31,7 +31,8 @@
 <div class="refnamediv"><table width="100%"><tr>
 <td valign="top">
 <h2><span class="refentrytitle"><a name="glib-Memory-Slices.top_of_page"></a>Memory Slices</span></h2>
-<p>Memory Slices — efficient way to allocate groups of equal-sized chunks of memory</p>
+<p>Memory Slices — efficient way to allocate groups of equal-sized
+    chunks of memory</p>
 </td>
 <td valign="top" align="right"></td>
 </tr></table></div>
@@ -66,13 +67,13 @@
 <p>
 Memory slices provide a space-efficient and multi-processing scalable
 way to allocate equal-sized pieces of memory, just like the original
-<a href="glib-Memory-Chunks.html#GMemChunk"><span class="type">GMemChunks</span></a> (from GLib &lt;= 2.8), while avoiding their excessive
+<span class="type">GMemChunks</span> (from GLib 2.8), while avoiding their excessive
 memory-waste, scalability and performance problems.
 </p>
 <p>
 To achieve these goals, the slice allocator uses a sophisticated,
 layered design that has been inspired by Bonwick's slab allocator
-<sup>[<a name="id830744" href="#ftn.id830744" class="footnote">6</a>]</sup>.
+<a href="#ftn.idp12596016" class="footnote"><sup class="footnote"><a name="idp12596016"></a>[1]</sup></a>.
 It uses <code class="function">posix_memalign()</code> to optimize allocations of many equally-sized
 chunks, and has per-thread free lists (the so-called magazine layer)
 to quickly satisfy allocation requests of already known structure sizes.
@@ -92,8 +93,10 @@ to use the new <code class="literal">g_slice</code> API instead of <a class="lin
 friends, as long as objects are not resized during their lifetime and the
 object size used at allocation time is still available when freeing.
 </p>
+<p>
+</p>
 <div class="example">
-<a name="id761296"></a><p class="title"><b>Example 15. Using the slice allocator</b></p>
+<a name="idp12113712"></a><p class="title"><b>Example 8. Using the slice allocator</b></p>
 <div class="example-contents">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
     <tbody>
@@ -112,17 +115,23 @@ object size used at allocation time is still available when freeing.
 12
 13
 14
-15</pre></td>
+15
+16
+17
+18</pre></td>
         <td class="listing_code"><pre class="programlisting"><span class="usertype">gchar</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">mem</span><span class="symbol">[</span><span class="number">10000</span><span class="symbol">];</span>
 <span class="usertype">gint</span><span class="normal"> i</span><span class="symbol">;</span>
 <span class="comment">/* Allocate 10000 blocks. */</span>
 <span class="keyword">for</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">i </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span><span class="normal"> i </span><span class="symbol">&lt;</span><span class="normal"> </span><span class="number">10000</span><span class="symbol">;</span><span class="normal"> i</span><span class="symbol">++)</span>
 <span class="normal">  </span><span class="cbracket">{</span>
 <span class="normal">    mem</span><span class="symbol">[</span><span class="normal">i</span><span class="symbol">]</span><span class="normal"> </span><span class="symbol">=</span><span class="normal"> </span><span class="function"><a href="glib-Memory-Slices.html#g-slice-alloc">g_slice_alloc</a></span><span class="normal"> </span><span class="symbol">(</span><span class="number">50</span><span class="symbol">);</span>
 <span class="normal">    </span><span class="comment">/* Fill in the memory with some junk. */</span>
 <span class="normal">    </span><span class="keyword">for</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">j </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span><span class="normal"> j </span><span class="symbol">&lt;</span><span class="normal"> </span><span class="number">50</span><span class="symbol">;</span><span class="normal"> j</span><span class="symbol">++)</span>
-<span class="normal">    mem</span><span class="symbol">[</span><span class="normal">i</span><span class="symbol">][</span><span class="normal">j</span><span class="symbol">]</span><span class="normal"> </span><span class="symbol">=</span><span class="normal"> i </span><span class="symbol">*</span><span class="normal"> j</span><span class="symbol">;</span>
+<span class="normal">      mem</span><span class="symbol">[</span><span class="normal">i</span><span class="symbol">][</span><span class="normal">j</span><span class="symbol">]</span><span class="normal"> </span><span class="symbol">=</span><span class="normal"> i </span><span class="symbol">*</span><span class="normal"> j</span><span class="symbol">;</span>
 <span class="normal">  </span><span class="cbracket">}</span>
 <span class="comment">/* Now free all of the blocks. */</span>
 <span class="keyword">for</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">i </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span><span class="normal"> i </span><span class="symbol">&lt;</span><span class="normal"> </span><span class="number">10000</span><span class="symbol">;</span><span class="normal"> i</span><span class="symbol">++)</span>
 <span class="normal">  </span><span class="cbracket">{</span>
@@ -134,8 +143,12 @@ object size used at allocation time is still available when freeing.
 </div>
 </div>
-<br class="example-break"><div class="example">
-<a name="id734059"></a><p class="title"><b>Example 16. Using the slice allocator with data structures</b></p>
+<p><br class="example-break">
+</p>
+<p>
+</p>
+<div class="example">
+<a name="idp9397696"></a><p class="title"><b>Example 9. Using the slice allocator with data structures</b></p>
 <div class="example-contents">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
     <tbody>
@@ -151,10 +164,15 @@ object size used at allocation time is still available when freeing.
 9
 10
 11
-12</pre></td>
+12
+13
+14
+15</pre></td>
         <td class="listing_code"><pre class="programlisting"><span class="usertype">GRealArray</span><span class="normal"> </span><span class="symbol">*</span><span class="normal">array</span><span class="symbol">;</span>
 <span class="comment">/* Allocate one block, using the g_slice_new() macro. */</span>
 <span class="normal">array </span><span class="symbol">=</span><span class="normal"> </span><span class="function"><a href="glib-Memory-Slices.html#g-slice-new">g_slice_new</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal">GRealArray</span><span class="symbol">);</span>
 <span class="comment">/* We can now use array just like a normal pointer to a structure. */</span>
 <span class="normal">array</span><span class="symbol">-&gt;</span><span class="normal">data            </span><span class="symbol">=</span><span class="normal"> <a href="glib-Standard-Macros.html#NULL:CAPS">NULL</a></span><span class="symbol">;</span>
 <span class="normal">array</span><span class="symbol">-&gt;</span><span class="normal">len             </span><span class="symbol">=</span><span class="normal"> </span><span class="number">0</span><span class="symbol">;</span>
@@ -162,6 +180,7 @@ object size used at allocation time is still available when freeing.
 <span class="normal">array</span><span class="symbol">-&gt;</span><span class="normal">zero_terminated </span><span class="symbol">=</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">zero_terminated </span><span class="symbol">?</span><span class="normal"> </span><span class="number">1</span><span class="normal"> </span><span class="symbol">:</span><span class="normal"> </span><span class="number">0</span><span class="symbol">);</span>
 <span class="normal">array</span><span class="symbol">-&gt;</span><span class="normal">clear           </span><span class="symbol">=</span><span class="normal"> </span><span class="symbol">(</span><span class="normal">clear </span><span class="symbol">?</span><span class="normal"> </span><span class="number">1</span><span class="normal"> </span><span class="symbol">:</span><span class="normal"> </span><span class="number">0</span><span class="symbol">);</span>
 <span class="normal">array</span><span class="symbol">-&gt;</span><span class="normal">elt_size        </span><span class="symbol">=</span><span class="normal"> elt_size</span><span class="symbol">;</span>
 <span class="comment">/* We can free the block, so it can be reused. */</span>
 <span class="function"><a href="glib-Memory-Slices.html#g-slice-free">g_slice_free</a></span><span class="normal"> </span><span class="symbol">(</span><span class="normal">GRealArray</span><span class="symbol">,</span><span class="normal"> array</span><span class="symbol">);</span></pre></td>
       </tr>
@@ -170,7 +189,8 @@ object size used at allocation time is still available when freeing.
 </div>
 </div>
-<br class="example-break">
+<p><br class="example-break">
+</p>
 </div>
 <div class="refsect1">
 <a name="glib-Memory-Slices.details"></a><h2>Details</h2>
@@ -188,8 +208,11 @@ Note that the underlying slice allocation mechanism can
 be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a>
 environment variable.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td>
@@ -208,14 +231,17 @@ environment variable.
 <a name="g-slice-alloc0"></a><h3>g_slice_alloc0 ()</h3>
 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_slice_alloc0                      (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>);</pre>
 <p>
-Allocates a block of memory via <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a>
-and initialize the returned memory to 0.
-Note that the underlying slice allocation mechanism can
-be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a>
+Allocates a block of memory via <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> and initializes
+the returned memory to 0. Note that the underlying slice allocation
+mechanism can be changed with the
+<a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a>
 environment variable.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td>
@@ -235,11 +261,14 @@ environment variable.
 <pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_slice_copy                        (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>,
                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> mem_block</code></em>);</pre>
 <p>
-Allocates a block of memory from the slice allocator and copies
-<em class="parameter"><code>block_size</code></em> bytes into it from <em class="parameter"><code>mem_block</code></em>.
+Allocates a block of memory from the slice allocator
+and copies <em class="parameter"><code>block_size</code></em> bytes into it from <em class="parameter"><code>mem_block</code></em>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td>
@@ -263,15 +292,22 @@ Allocates a block of memory from the slice allocator and copies
 <pre class="programlisting"><span class="returnvalue">void</span>                g_slice_free1                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> block_size</code></em>,
                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem_block</code></em>);</pre>
 <p>
-Frees a block of memory. The memory must have been allocated via
-<a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a>
-and the <em class="parameter"><code>block_size</code></em> has to match the size specified upon allocation.
-Note that the exact release behaviour can be changed with the
-<a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable,
-also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options.
+Frees a block of memory.
+</p>
+<p>
+The memory must have been allocated via <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or
+<a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> and the <em class="parameter"><code>block_size</code></em> has to match the size
+specified upon allocation. Note that the exact release behaviour
+can be changed with the
+G_DEBUG=gc-friendly environment
+variable, also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for
+related debugging options.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td>
@@ -293,16 +329,22 @@ also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLIC
                                                          <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> next_offset</code></em>);</pre>
 <p>
 Frees a linked list of memory blocks of structure type <em class="parameter"><code>type</code></em>.
+</p>
+<p>
 The memory blocks must be equal-sized, allocated via
-<a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a>
-and linked together by a <em class="parameter"><code>next</code></em> pointer (similar to <a class="link" href="glib-Singly-Linked-Lists.html#GSList" title="struct GSList"><span class="type">GSList</span></a>). The offset
-of the <em class="parameter"><code>next</code></em> field in each block is passed as third argument.
+<a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> and linked together by a
+<em class="parameter"><code>next</code></em> pointer (similar to <a class="link" href="glib-Singly-Linked-Lists.html#GSList" title="struct GSList"><span class="type">GSList</span></a>). The offset of the <em class="parameter"><code>next</code></em>
+field in each block is passed as third argument.
 Note that the exact release behaviour can be changed with the
-<a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable,
-also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options.
+G_DEBUG=gc-friendly environment
+variable, also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for
+related debugging options.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>block_size</code></em> :</span></p></td>
@@ -325,16 +367,22 @@ also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLIC
 <a name="g-slice-new"></a><h3>g_slice_new()</h3>
 <pre class="programlisting">#define             g_slice_new(type)</pre>
 <p>
-A convenience macro to allocate a block of memory from the slice allocator.
-It calls <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code> and casts
-the returned pointer to a pointer of the given type, avoiding a type cast
-in the source code.
+A convenience macro to allocate a block of memory from the
+slice allocator.
+</p>
+<p>
+It calls <a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code>
+and casts the returned pointer to a pointer of the given type,
+avoiding a type cast in the source code.
 Note that the underlying slice allocation mechanism can
 be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a>
 environment variable.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
@@ -342,7 +390,8 @@ environment variable.
 </tr>
 <tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>.</td>
+<td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>
+</td>
 </tr>
 </tbody>
 </table></div>
@@ -353,26 +402,26 @@ environment variable.
 <a name="g-slice-new0"></a><h3>g_slice_new0()</h3>
 <pre class="programlisting">#define             g_slice_new0(type)</pre>
 <p>
-A convenience macro to allocate a block of memory from the slice allocator
-and set the memory to 0. It calls <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> with
-<code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code> and casts the returned pointer to a pointer
-of the given type, avoiding a type cast in the source code.
+A convenience macro to allocate a block of memory from the
+slice allocator and set the memory to 0.
+</p>
+<p>
+It calls <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code>
+and casts the returned pointer to a pointer of the given type,
+avoiding a type cast in the source code.
 Note that the underlying slice allocation mechanism can
 be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a>
 environment variable.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
-<tbody>
-<tr>
+<col>
+</colgroup>
+<tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
 <td>the type to allocate, typically a structure name</td>
-</tr>
-<tr>
-<td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>.</td>
-</tr>
-</tbody>
+</tr></tbody>
 </table></div>
 <p class="since">Since 2.10</p>
 </div>
@@ -381,16 +430,22 @@ environment variable.
 <a name="g-slice-dup"></a><h3>g_slice_dup()</h3>
 <pre class="programlisting">#define             g_slice_dup(type, mem)</pre>
 <p>
-A convenience macro to duplicate a block of memory using the slice allocator.
-It calls <a class="link" href="glib-Memory-Slices.html#g-slice-copy" title="g_slice_copy ()"><code class="function">g_slice_copy()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code> and casts
-the returned pointer to a pointer of the given type, avoiding a type cast
-in the source code.
+A convenience macro to duplicate a block of memory using
+the slice allocator.
+</p>
+<p>
+It calls <a class="link" href="glib-Memory-Slices.html#g-slice-copy" title="g_slice_copy ()"><code class="function">g_slice_copy()</code></a> with <code class="literal">sizeof (<em class="parameter"><code>type</code></em>)</code>
+and casts the returned pointer to a pointer of the given type,
+avoiding a type cast in the source code.
 Note that the underlying slice allocation mechanism can
 be changed with the <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE=always-malloc</a>
 environment variable.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
@@ -402,7 +457,8 @@ environment variable.
 </tr>
 <tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>.</td>
+<td>a pointer to the allocated block, cast to a pointer to <em class="parameter"><code>type</code></em>
+</td>
 </tr>
 </tbody>
 </table></div>
@@ -413,15 +469,22 @@ environment variable.
 <a name="g-slice-free"></a><h3>g_slice_free()</h3>
 <pre class="programlisting">#define             g_slice_free(type, mem)</pre>
 <p>
-A convenience macro to free a block of memory that has been allocated
-from the slice allocator. It calls <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()"><code class="function">g_slice_free1()</code></a> using
-<code class="literal">sizeof (type)</code> as the block size.
+A convenience macro to free a block of memory that has
+been allocated from the slice allocator.
+</p>
+<p>
+It calls <a class="link" href="glib-Memory-Slices.html#g-slice-free1" title="g_slice_free1 ()"><code class="function">g_slice_free1()</code></a> using <code class="literal">sizeof (type)</code>
+as the block size.
 Note that the exact release behaviour can be changed with the
-<a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable,
-also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options.
+G_DEBUG=gc-friendly environment
+variable, also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for
+related debugging options.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
@@ -442,15 +505,19 @@ also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLIC
 <p>
 Frees a linked list of memory blocks of structure type <em class="parameter"><code>type</code></em>.
 The memory blocks must be equal-sized, allocated via
-<a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> and linked together by a
-<em class="parameter"><code>next</code></em> pointer (similar to <a class="link" href="glib-Singly-Linked-Lists.html#GSList" title="struct GSList"><span class="type">GSList</span></a>). The name of the
+<a class="link" href="glib-Memory-Slices.html#g-slice-alloc" title="g_slice_alloc ()"><code class="function">g_slice_alloc()</code></a> or <a class="link" href="glib-Memory-Slices.html#g-slice-alloc0" title="g_slice_alloc0 ()"><code class="function">g_slice_alloc0()</code></a> and linked together by
+a <em class="parameter"><code>next</code></em> pointer (similar to <a class="link" href="glib-Singly-Linked-Lists.html#GSList" title="struct GSList"><span class="type">GSList</span></a>). The name of the
 <em class="parameter"><code>next</code></em> field in <em class="parameter"><code>type</code></em> is passed as third argument.
 Note that the exact release behaviour can be changed with the
-<a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">G_DEBUG=gc-friendly</a> environment variable,
-also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for related debugging options.
+G_DEBUG=gc-friendly environment
+variable, also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLICE</a> for
+related debugging options.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>type</code></em> :</span></p></td>
@@ -471,8 +538,8 @@ also see <a class="link" href="glib-running.html#G_SLICE" title="G_SLICE">G_SLIC
 </div>
 </div>
 <div class="footnotes">
-<br><hr width="100" align="left">
-<div class="footnote"><p><sup>[<a id="ftn.id830744" href="#id830744" class="para">6</a>] </sup>
+<br><hr style="width:100; align:left;">
+<div id="ftn.idp12596016" class="footnote"><p><a href="#idp12596016" class="para"><sup class="para">[1] </sup></a>
 <a class="ulink" href="http://citeseer.ist.psu.edu/bonwick94slab.html" target="_top">[Bonwick94]</a> Jeff Bonwick, The slab allocator: An object-caching kernel
 memory allocator. USENIX 1994, and
 <a class="ulink" href="http://citeseer.ist.psu.edu/bonwick01magazines.html" target="_top">[Bonwick01]</a> Bonwick and Jonathan Adams, Magazines and vmem: Extending the
@@ -482,6 +549,6 @@ slab allocator to many cpu's and arbitrary resources. USENIX 2001
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.17</div>
+          Generated by GTK-Doc V1.18</div>
 </body>
 </html>

data/vendor/local/share/gtk-doc/html/glib/glib-Message-Logging.html CHANGED

@@ -3,12 +3,12 @@
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Message Logging</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
+<meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
 <link rel="home" href="index.html" title="GLib Reference Manual">
 <link rel="up" href="glib-core.html" title="GLib Core Application Support">
 <link rel="prev" href="glib-Warnings-and-Assertions.html" title="Message Output and Debugging Functions">
 <link rel="next" href="glib-utilities.html" title="GLib Utilities">
-<meta name="generator" content="GTK-Doc V1.17 (XML mode)">
+<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
 <link rel="stylesheet" href="style.css" type="text/css">
 </head>
 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
@@ -31,7 +31,8 @@
 <div class="refnamediv"><table width="100%"><tr>
 <td valign="top">
 <h2><span class="refentrytitle"><a name="glib-Message-Logging.top_of_page"></a>Message Logging</span></h2>
-<p>Message Logging — versatile support for logging messages with different levels of importance</p>
+<p>Message Logging — versatile support for logging messages
+    with different levels of importance</p>
 </td>
 <td valign="top" align="right"></td>
 </tr></table></div>
@@ -83,12 +84,12 @@ enum                <a class="link" href="glib-Message-Logging.html#GLogLevelFla
 <div class="refsect1">
 <a name="glib-Message-Logging.description"></a><h2>Description</h2>
 <p>
-These functions provide support for logging error messages or messages
-used for debugging.
+These functions provide support for logging error messages
+or messages used for debugging.
 </p>
 <p>
-There are several built-in levels of messages, defined in <a class="link" href="glib-Message-Logging.html#GLogLevelFlags" title="enum GLogLevelFlags"><span class="type">GLogLevelFlags</span></a>.
-These can be extended with user-defined levels.
+There are several built-in levels of messages, defined in
+<a class="link" href="glib-Message-Logging.html#GLogLevelFlags" title="enum GLogLevelFlags"><span class="type">GLogLevelFlags</span></a>. These can be extended with user-defined levels.
 </p>
 </div>
 <div class="refsect1">
@@ -99,10 +100,13 @@ These can be extended with user-defined levels.
 </pre>
 <p>
 Defines the log domain.
-For applications, this is typically left as the default <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> (or "") domain.
-Libraries should define this so that any messages which they log can
-be differentiated from messages from other libraries and application code.
-But be careful not to define it in any public header files.
+</p>
+<p>
+For applications, this is typically left as the default <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
+(or "") domain. Libraries should define this so that any messages
+which they log can be differentiated from messages from other
+libraries and application code. But be careful not to define
+it in any public header files.
 </p>
 <p>
 For example, GTK+ uses this in its Makefile.am:
@@ -118,6 +122,8 @@ For example, GTK+ uses this in its Makefile.am:
   </table>
 </div>
+<p>
+</p>
 </div>
 <hr>
 <div class="refsect2">
@@ -133,9 +139,6 @@ GLib log levels that are considered fatal by default.
 <a name="G-LOG-LEVEL-USER-SHIFT:CAPS"></a><h3>G_LOG_LEVEL_USER_SHIFT</h3>
 <pre class="programlisting">#define G_LOG_LEVEL_USER_SHIFT  (8)
 </pre>
-<p>
-Log level shift offset for user defined log levels (0-7 are used by GLib).
-</p>
 </div>
 <hr>
 <div class="refsect2">
@@ -147,25 +150,29 @@ Log level shift offset for user defined log levels (0-7 are used by GLib).
 <p>
 Specifies the prototype of log handler functions.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain of the message.</td>
+<td>the log domain of the message</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_level</code></em> :</span></p></td>
-<td>the log level of the message (including the fatal and recursion
-flags).</td>
+<td>the log level of the message (including the
+fatal and recursion flags)</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>message</code></em> :</span></p></td>
-<td>the message to process.</td>
+<td>the message to process</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>user_data</code></em> :</span></p></td>
-<td>user data, set in <a class="link" href="glib-Message-Logging.html#g-log-set-handler" title="g_log_set_handler ()"><code class="function">g_log_set_handler()</code></a>.</td>
+<td>user data, set in <a class="link" href="glib-Message-Logging.html#g-log-set-handler" title="g_log_set_handler ()"><code class="function">g_log_set_handler()</code></a>
+</td>
 </tr>
 </tbody>
 </table></div>
@@ -173,8 +180,7 @@ flags).</td>
 <hr>
 <div class="refsect2">
 <a name="GLogLevelFlags"></a><h3>enum GLogLevelFlags</h3>
-<pre class="programlisting">typedef enum
-{
+<pre class="programlisting">typedef enum {
   /* log flags */
   G_LOG_FLAG_RECURSION          = 1 &lt;&lt; 0,
   G_LOG_FLAG_FATAL              = 1 &lt;&lt; 1,
@@ -191,12 +197,17 @@ flags).</td>
 } GLogLevelFlags;
 </pre>
 <p>
-Flags specifying the level of log messages. It is possible to change
-how GLib treats messages of the various levels using <a class="link" href="glib-Message-Logging.html#g-log-set-handler" title="g_log_set_handler ()"><code class="function">g_log_set_handler()</code></a>
-and <a class="link" href="glib-Message-Logging.html#g-log-set-fatal-mask" title="g_log_set_fatal_mask ()"><code class="function">g_log_set_fatal_mask()</code></a>.
+Flags specifying the level of log messages.
+</p>
+<p>
+It is possible to change how GLib treats messages of the various
+levels using <a class="link" href="glib-Message-Logging.html#g-log-set-handler" title="g_log_set_handler ()"><code class="function">g_log_set_handler()</code></a> and <a class="link" href="glib-Message-Logging.html#g-log-set-fatal-mask" title="g_log_set_fatal_mask ()"><code class="function">g_log_set_fatal_mask()</code></a>.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><a name="G-LOG-FLAG-RECURSION:CAPS"></a><span class="term"><code class="literal">G_LOG_FLAG_RECURSION</code></span></p></td>
@@ -210,15 +221,15 @@ and <a class="link" href="glib-Message-Logging.html#g-log-set-fatal-mask" title=
 </tr>
 <tr>
 <td><p><a name="G-LOG-LEVEL-ERROR:CAPS"></a><span class="term"><code class="literal">G_LOG_LEVEL_ERROR</code></span></p></td>
-<td>log level for errors, see <a class="link" href="glib-Message-Logging.html#g-error" title="g_error()"><code class="function">g_error()</code></a>.
-  This level is also used for messages produced by <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>.
+<td>log level for errors, see <a class="link" href="glib-Message-Logging.html#g-error" title="g_error()"><code class="function">g_error()</code></a>.
+    This level is also used for messages produced by <a class="link" href="glib-Testing.html#g-assert" title="g_assert()"><code class="function">g_assert()</code></a>.
 </td>
 </tr>
 <tr>
 <td><p><a name="G-LOG-LEVEL-CRITICAL:CAPS"></a><span class="term"><code class="literal">G_LOG_LEVEL_CRITICAL</code></span></p></td>
 <td>log level for critical messages, see <a class="link" href="glib-Message-Logging.html#g-critical" title="g_critical()"><code class="function">g_critical()</code></a>.
-  This level is also used for messages produced by <a class="link" href="glib-Warnings-and-Assertions.html#g-return-if-fail" title="g_return_if_fail()"><code class="function">g_return_if_fail()</code></a> and
-  <a class="link" href="glib-Warnings-and-Assertions.html#g-return-val-if-fail" title="g_return_val_if_fail()"><code class="function">g_return_val_if_fail()</code></a>.
+    This level is also used for messages produced by <a class="link" href="glib-Warnings-and-Assertions.html#g-return-if-fail" title="g_return_if_fail()"><code class="function">g_return_if_fail()</code></a>
+    and <a class="link" href="glib-Warnings-and-Assertions.html#g-return-val-if-fail" title="g_return_val_if_fail()"><code class="function">g_return_val_if_fail()</code></a>.
 </td>
 </tr>
 <tr>
@@ -243,7 +254,7 @@ and <a class="link" href="glib-Message-Logging.html#g-log-set-fatal-mask" title=
 </tr>
 <tr>
 <td><p><a name="G-LOG-LEVEL-MASK:CAPS"></a><span class="term"><code class="literal">G_LOG_LEVEL_MASK</code></span></p></td>
-<td>a mask including all log levels.
+<td>a mask including all log levels
 </td>
 </tr>
 </tbody>
@@ -258,28 +269,34 @@ and <a class="link" href="glib-Message-Logging.html#g-log-set-fatal-mask" title=
                                                          <em class="parameter"><code>...</code></em>);</pre>
 <p>
 Logs an error or debugging message.
+</p>
+<p>
 If the log level has been set as fatal, the <code class="function">abort()</code>
 function is called to terminate the program.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain, usually <a class="link" href="glib-Message-Logging.html#G-LOG-DOMAIN:CAPS" title="G_LOG_DOMAIN"><span class="type">G_LOG_DOMAIN</span></a>.</td>
+<td>the log domain, usually <a class="link" href="glib-Message-Logging.html#G-LOG-DOMAIN:CAPS" title="G_LOG_DOMAIN"><span class="type">G_LOG_DOMAIN</span></a>
+</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_level</code></em> :</span></p></td>
-<td>the log level, either from <a class="link" href="glib-Message-Logging.html#GLogLevelFlags" title="enum GLogLevelFlags"><span class="type">GLogLevelFlags</span></a> or a user-defined level.</td>
+<td>the log level, either from <a class="link" href="glib-Message-Logging.html#GLogLevelFlags" title="enum GLogLevelFlags"><span class="type">GLogLevelFlags</span></a>
+or a user-defined level</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>format</code></em> :</span></p></td>
-<td>the message format. See the <code class="function">printf()</code>
-documentation.</td>
+<td>the message format. See the <code class="function">printf()</code> documentation</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>...</code></em> :</span></p></td>
-<td>the parameters to insert into the format string.</td>
+<td>the parameters to insert into the format string</td>
 </tr>
 </tbody>
 </table></div>
@@ -293,28 +310,32 @@ documentation.</td>
                                                          <em class="parameter"><code><span class="type">va_list</span> args</code></em>);</pre>
 <p>
 Logs an error or debugging message.
+</p>
+<p>
 If the log level has been set as fatal, the <code class="function">abort()</code>
 function is called to terminate the program.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain.</td>
+<td>the log domain</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_level</code></em> :</span></p></td>
-<td>the log level.</td>
+<td>the log level</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>format</code></em> :</span></p></td>
-<td>the message format. See the <code class="function">printf()</code>
-documentation.</td>
+<td>the message format. See the <code class="function">printf()</code> documentation</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>args</code></em> :</span></p></td>
-<td>the parameters to insert into the format string.</td>
+<td>the parameters to insert into the format string</td>
 </tr>
 </tbody>
 </table></div>
@@ -326,11 +347,15 @@ documentation.</td>
 <p>
 A convenience function/macro to log a normal message.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>...</code></em> :</span></p></td>
-<td>format string, followed by parameters to insert into the format string (as with <code class="function">printf()</code>)</td>
+<td>format string, followed by parameters to insert
+into the format string (as with <code class="function">printf()</code>)</td>
 </tr></tbody>
 </table></div>
 </div>
@@ -342,14 +367,19 @@ A convenience function/macro to log a normal message.
 A convenience function/macro to log a warning message.
 </p>
 <p>
-You can make warnings fatal at runtime by setting the <code class="literal">G_DEBUG</code> environment
-variable (see <a class="ulink" href="glib-running.html" target="_top">Running GLib Applications</a>).
+You can make warnings fatal at runtime by setting the
+<code class="envar">G_DEBUG</code> environment variable (see
+<a class="ulink" href="glib-running.html" target="_top">Running GLib Applications</a>).
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>...</code></em> :</span></p></td>
-<td>format string, followed by parameters to insert into the format string (as with <code class="function">printf()</code>)</td>
+<td>format string, followed by parameters to insert
+into the format string (as with <code class="function">printf()</code>)</td>
 </tr></tbody>
 </table></div>
 </div>
@@ -358,22 +388,27 @@ variable (see <a class="ulink" href="glib-running.html" target="_top">Running GL
 <a name="g-critical"></a><h3>g_critical()</h3>
 <pre class="programlisting">#define             g_critical(...)</pre>
 <p>
-Logs a "critical warning" (<a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-CRITICAL:CAPS"><span class="type">G_LOG_LEVEL_CRITICAL</span></a>). It's more or less
-application-defined what constitutes a critical vs. a regular
-warning. You could call <a class="link" href="glib-Message-Logging.html#g-log-set-always-fatal" title="g_log_set_always_fatal ()"><code class="function">g_log_set_always_fatal()</code></a> to make critical
-warnings exit the program, then use <a class="link" href="glib-Message-Logging.html#g-critical" title="g_critical()"><code class="function">g_critical()</code></a> for fatal errors, for
+Logs a "critical warning" (<a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-CRITICAL:CAPS"><span class="type">G_LOG_LEVEL_CRITICAL</span></a>).
+It's more or less application-defined what constitutes
+a critical vs. a regular warning. You could call
+<a class="link" href="glib-Message-Logging.html#g-log-set-always-fatal" title="g_log_set_always_fatal ()"><code class="function">g_log_set_always_fatal()</code></a> to make critical warnings exit
+the program, then use <a class="link" href="glib-Message-Logging.html#g-critical" title="g_critical()"><code class="function">g_critical()</code></a> for fatal errors, for
 example.
 </p>
 <p>
-You can also make critical warnings fatal at runtime by setting
-the <code class="literal">G_DEBUG</code> environment variable (see
+You can also make critical warnings fatal at runtime by
+setting the <code class="envar">G_DEBUG</code> environment variable (see
 <a class="ulink" href="glib-running.html" target="_top">Running GLib Applications</a>).
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>...</code></em> :</span></p></td>
-<td>format string, followed by parameters to insert into the format string (as with <code class="function">printf()</code>)</td>
+<td>format string, followed by parameters to insert
+into the format string (as with <code class="function">printf()</code>)</td>
 </tr></tbody>
 </table></div>
 </div>
@@ -383,17 +418,23 @@ the <code class="literal">G_DEBUG</code> environment variable (see
 <pre class="programlisting">#define             g_error(...)</pre>
 <p>
 A convenience function/macro to log an error message.
+</p>
+<p>
 Error messages are always fatal, resulting in a call to
-<code class="function">abort()</code> to terminate the application.
-This function will result in a core dump; don't use it for errors you
-expect. Using this function indicates a bug in your program, i.e. an
-assertion failure.
+<code class="function">abort()</code> to terminate the application. This function will
+result in a core dump; don't use it for errors you expect.
+Using this function indicates a bug in your program, i.e.
+an assertion failure.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>...</code></em> :</span></p></td>
-<td>format string, followed by parameters to insert into the format string (as with <code class="function">printf()</code>)</td>
+<td>format string, followed by parameters to insert
+into the format string (as with <code class="function">printf()</code>)</td>
 </tr></tbody>
 </table></div>
 </div>
@@ -404,11 +445,15 @@ assertion failure.
 <p>
 A convenience function/macro to log a debug message.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody><tr>
 <td><p><span class="term"><em class="parameter"><code>...</code></em> :</span></p></td>
-<td>format string, followed by parameters to insert into the format string (as with <code class="function">printf()</code>)</td>
+<td>format string, followed by parameters to insert
+into the format string (as with <code class="function">printf()</code>)</td>
 </tr></tbody>
 </table></div>
 <p class="since">Since 2.6</p>
@@ -431,8 +476,10 @@ Note that since the <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-
 you want to set a handler for this log level you must combine it with
 <a class="link" href="glib-Message-Logging.html#G-LOG-FLAG-FATAL:CAPS"><span class="type">G_LOG_FLAG_FATAL</span></a>.
 </p>
+<p>
+</p>
 <div class="example">
-<a name="id727199"></a><p class="title"><b>Example 12. Adding a log handler for all warning messages in the default
+<a name="idp20960640"></a><p class="title"><b>Example 10. Adding a log handler for all warning messages in the default
 (application) domain</b></p>
 <div class="example-contents">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
@@ -448,8 +495,12 @@ you want to set a handler for this log level you must combine it with
 </div>
 </div>
-<br class="example-break"><div class="example">
-<a name="id727214"></a><p class="title"><b>Example 13. Adding a log handler for all critical messages from GTK+</b></p>
+<p><br class="example-break">
+</p>
+<p>
+</p>
+<div class="example">
+<a name="idp20962864"></a><p class="title"><b>Example 11. Adding a log handler for all critical messages from GTK+</b></p>
 <div class="example-contents">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
     <tbody>
@@ -464,8 +515,12 @@ you want to set a handler for this log level you must combine it with
 </div>
 </div>
-<br class="example-break"><div class="example">
-<a name="id727229"></a><p class="title"><b>Example 14. Adding a log handler for <span class="emphasis"><em>all</em></span> messages from
+<p><br class="example-break">
+</p>
+<p>
+</p>
+<div class="example">
+<a name="idp20965088"></a><p class="title"><b>Example 12. Adding a log handler for <span class="emphasis"><em>all</em></span> messages from
 GLib</b></p>
 <div class="example-contents">
   <table class="listing_frame" border="0" cellpadding="0" cellspacing="0">
@@ -481,30 +536,38 @@ GLib</b></p>
 </div>
 </div>
-<br class="example-break"><div class="variablelist"><table border="0">
+<p><br class="example-break">
+</p>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> for the default "" application domain.</td>
+<td>the log domain, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> for the default ""
+application domain. <span class="annotation">[<acronym title="NULL is ok, both for passing and for returning."><span class="acronym">allow-none</span></acronym>]</span>
+</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_levels</code></em> :</span></p></td>
-<td>the log levels to apply the log handler for. To handle fatal
-and recursive messages as well, combine the log levels with the
-<a class="link" href="glib-Message-Logging.html#G-LOG-FLAG-FATAL:CAPS"><span class="type">G_LOG_FLAG_FATAL</span></a> and <a class="link" href="glib-Message-Logging.html#G-LOG-FLAG-RECURSION:CAPS"><span class="type">G_LOG_FLAG_RECURSION</span></a> bit flags.</td>
+<td>the log levels to apply the log handler for.
+To handle fatal and recursive messages as well, combine
+the log levels with the <a class="link" href="glib-Message-Logging.html#G-LOG-FLAG-FATAL:CAPS"><span class="type">G_LOG_FLAG_FATAL</span></a> and
+<a class="link" href="glib-Message-Logging.html#G-LOG-FLAG-RECURSION:CAPS"><span class="type">G_LOG_FLAG_RECURSION</span></a> bit flags.</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_func</code></em> :</span></p></td>
-<td>the log handler function.</td>
+<td>the log handler function</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>user_data</code></em> :</span></p></td>
-<td>data passed to the log handler.</td>
+<td>data passed to the log handler</td>
 </tr>
 <tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the id of the new handler.</td>
+<td>the id of the new handler</td>
 </tr>
 </tbody>
 </table></div>
@@ -517,16 +580,21 @@ and recursive messages as well, combine the log levels with the
 <p>
 Removes the log handler.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain.</td>
+<td>the log domain</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>handler_id</code></em> :</span></p></td>
-<td>the id of the handler, which was returned in <a class="link" href="glib-Message-Logging.html#g-log-set-handler" title="g_log_set_handler ()"><code class="function">g_log_set_handler()</code></a>.</td>
+<td>the id of the handler, which was returned
+in <a class="link" href="glib-Message-Logging.html#g-log-set-handler" title="g_log_set_handler ()"><code class="function">g_log_set_handler()</code></a>
+</td>
 </tr>
 </tbody>
 </table></div>
@@ -542,21 +610,24 @@ You can only set the levels defined by GLib to be fatal.
 <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-ERROR:CAPS"><code class="literal">G_LOG_LEVEL_ERROR</code></a> is always fatal.
 </p>
 <p>
-You can also make some message levels
-fatal at runtime by setting the <code class="literal">G_DEBUG</code> environment variable (see
+You can also make some message levels fatal at runtime by setting
+the <code class="envar">G_DEBUG</code> environment variable (see
 <a class="ulink" href="glib-running.html" target="_top">Running GLib Applications</a>).
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>fatal_mask</code></em> :</span></p></td>
-<td>the mask containing bits set for each level of error which is
-to be fatal.</td>
+<td>the mask containing bits set for each level
+of error which is to be fatal</td>
 </tr>
 <tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the old fatal mask.</td>
+<td>the old fatal mask</td>
 </tr>
 </tbody>
 </table></div>
@@ -570,20 +641,23 @@ to be fatal.</td>
 Sets the log levels which are fatal in the given domain.
 <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-ERROR:CAPS"><code class="literal">G_LOG_LEVEL_ERROR</code></a> is always fatal.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain.</td>
+<td>the log domain</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>fatal_mask</code></em> :</span></p></td>
-<td>the new fatal mask.</td>
+<td>the new fatal mask</td>
 </tr>
 <tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the old fatal mask for the log domain.</td>
+<td>the old fatal mask for the log domain</td>
 </tr>
 </tbody>
 </table></div>
@@ -598,32 +672,65 @@ Sets the log levels which are fatal in the given domain.
 <p>
 The default log handler set up by GLib; <a class="link" href="glib-Message-Logging.html#g-log-set-default-handler" title="g_log_set_default_handler ()"><code class="function">g_log_set_default_handler()</code></a>
 allows to install an alternate default log handler.
-This is used if no log handler has been set for the particular log domain
-and log level combination. It outputs the message to stderr or stdout
-and if the log level is fatal it calls <code class="function">abort()</code>.
+This is used if no log handler has been set for the particular log
+domain and log level combination. It outputs the message to stderr
+or stdout and if the log level is fatal it calls <code class="function">abort()</code>.
+</p>
+<p>
+The behavior of this log handler can be influenced by a number of
+environment variables:
+</p>
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
+<col align="left" valign="top">
+<col>
+</colgroup>
+<tbody>
+<tr>
+<td><p><span class="term"><code class="envar">G_MESSAGES_PREFIXED</code></span></p></td>
+<td>
+      A :-separated list of log levels for which messages should
+      be prefixed by the program name and PID of the aplication.
+    </td>
+</tr>
+<tr>
+<td><p><span class="term"><code class="envar">G_MESSAGES_DEBUG</code></span></p></td>
+<td>
+      A space-separated list of log domains for which debug and
+      informational messages are printed. By default these
+      messages are not printed.
+    </td>
+</tr>
+</tbody>
+</table></div>
+<p>
 </p>
 <p>
 stderr is used for levels <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-ERROR:CAPS"><code class="literal">G_LOG_LEVEL_ERROR</code></a>, <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-CRITICAL:CAPS"><code class="literal">G_LOG_LEVEL_CRITICAL</code></a>,
-<a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-WARNING:CAPS"><code class="literal">G_LOG_LEVEL_WARNING</code></a> and <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-MESSAGE:CAPS"><code class="literal">G_LOG_LEVEL_MESSAGE</code></a>. stdout is used for the rest.
+<a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-WARNING:CAPS"><code class="literal">G_LOG_LEVEL_WARNING</code></a> and <a class="link" href="glib-Message-Logging.html#G-LOG-LEVEL-MESSAGE:CAPS"><code class="literal">G_LOG_LEVEL_MESSAGE</code></a>. stdout is used for
+the rest.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_domain</code></em> :</span></p></td>
-<td>the log domain of the message.</td>
+<td>the log domain of the message</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_level</code></em> :</span></p></td>
-<td>the level of the message.</td>
+<td>the level of the message</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>message</code></em> :</span></p></td>
-<td>the message.</td>
+<td>the message</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>unused_data</code></em> :</span></p></td>
-<td>data passed from <a class="link" href="glib-Message-Logging.html#g-log" title="g_log ()"><code class="function">g_log()</code></a> which is unused.</td>
+<td>data passed from <a class="link" href="glib-Message-Logging.html#g-log" title="g_log ()"><code class="function">g_log()</code></a> which is unused</td>
 </tr>
 </tbody>
 </table></div>
@@ -639,16 +746,19 @@ log handler has been set for the particular log domain
 and log level combination. By default, GLib uses
 <a class="link" href="glib-Message-Logging.html#g-log-default-handler" title="g_log_default_handler ()"><code class="function">g_log_default_handler()</code></a> as default log handler.
 </p>
-<div class="variablelist"><table border="0">
+<div class="variablelist"><table border="0" class="variablelist">
+<colgroup>
 <col align="left" valign="top">
+<col>
+</colgroup>
 <tbody>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>log_func</code></em> :</span></p></td>
-<td>the log handler function.</td>
+<td>the log handler function</td>
 </tr>
 <tr>
 <td><p><span class="term"><em class="parameter"><code>user_data</code></em> :</span></p></td>
-<td>data passed to the log handler.</td>
+<td>data passed to the log handler</td>
 </tr>
 <tr>
 <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -662,6 +772,6 @@ and log level combination. By default, GLib uses
 </div>
 <div class="footer">
 <hr>
-          Generated by GTK-Doc V1.17</div>
+          Generated by GTK-Doc V1.18</div>
 </body>
 </html>