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

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>