Tizen 2.1 base

[platform/upstream/glib2.0.git] / docs / reference / glib / html / glib-Memory-Allocation.html
diff --git a/docs/reference/glib/html/glib-Memory-Allocation.html b/docs/reference/glib/html/glib-Memory-Allocation.html

index 4897010..5edc172 100644 (file)
--- a/docs/reference/glib/html/glib-Memory-Allocation.html
+++ b/docs/reference/glib/html/glib-Memory-Allocation.html
@@ -3,33 +3,13 @@
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Memory Allocation</title>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Memory Allocation</title>
-<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<meta name="generator" content="DocBook XSL Stylesheets V1.76.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-Dynamic-Loading-of-Modules.html" title="Dynamic Loading of Modules">
  <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-Dynamic-Loading-of-Modules.html" title="Dynamic Loading of Modules">
-<link rel="next" href="glib-IO-Channels.html" title="IO Channels">
-<meta name="generator" content="GTK-Doc V1.13 (XML mode)">
+<link rel="next" href="glib-Memory-Slices.html" title="Memory Slices">
+<meta name="generator" content="GTK-Doc V1.18 (XML mode)">
  <link rel="stylesheet" href="style.css" type="text/css">
  <link rel="stylesheet" href="style.css" type="text/css">
-<link rel="chapter" href="glib.html" title="GLib Overview">
-<link rel="chapter" href="glib-fundamentals.html" title="GLib Fundamentals">
-<link rel="chapter" href="glib-core.html" title="GLib Core Application Support">
-<link rel="chapter" href="glib-utilities.html" title="GLib Utilities">
-<link rel="chapter" href="glib-data-types.html" title="GLib Data Types">
-<link rel="chapter" href="tools.html" title="GLib Tools">
-<link rel="index" href="api-index-full.html" title="Index">
-<link rel="index" href="api-index-deprecated.html" title="Index of deprecated symbols">
-<link rel="index" href="api-index-2-2.html" title="Index of new symbols in 2.2">
-<link rel="index" href="api-index-2-4.html" title="Index of new symbols in 2.4">
-<link rel="index" href="api-index-2-6.html" title="Index of new symbols in 2.6">
-<link rel="index" href="api-index-2-8.html" title="Index of new symbols in 2.8">
-<link rel="index" href="api-index-2-10.html" title="Index of new symbols in 2.10">
-<link rel="index" href="api-index-2-12.html" title="Index of new symbols in 2.12">
-<link rel="index" href="api-index-2-14.html" title="Index of new symbols in 2.14">
-<link rel="index" href="api-index-2-16.html" title="Index of new symbols in 2.16">
-<link rel="index" href="api-index-2-18.html" title="Index of new symbols in 2.18">
-<link rel="index" href="api-index-2-20.html" title="Index of new symbols in 2.20">
-<link rel="index" href="api-index-2-22.html" title="Index of new symbols in 2.22">
-<link rel="index" href="api-index-2-24.html" title="Index of new symbols in 2.24">
  </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">
  </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">
@@ -38,7 +18,7 @@
  <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="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-IO-Channels.html"><img src="right.png" width="24" height="24" border="0" alt="Next"></a></td>
+<td><a accesskey="n" href="glib-Memory-Slices.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-Allocation.synopsis" class="shortcut">Top</a>
  </tr>
  <tr><td colspan="5" class="shortcuts">
  <a href="#glib-Memory-Allocation.synopsis" class="shortcut">Top</a>
@@ -46,7 +26,7 @@
                    <a href="#glib-Memory-Allocation.description" class="shortcut">Description</a>
  </td></tr>
  </table>
                    <a href="#glib-Memory-Allocation.description" class="shortcut">Description</a>
  </td></tr>
  </table>
-<div class="refentry" title="Memory Allocation">
+<div class="refentry">
  <a name="glib-Memory-Allocation"></a><div class="titlepage"></div>
  <div class="refnamediv"><table width="100%"><tr>
  <td valign="top">
  <a name="glib-Memory-Allocation"></a><div class="titlepage"></div>
  <div class="refnamediv"><table width="100%"><tr>
  <td valign="top">
@@ -55,85 +35,100 @@
  </td>
  <td valign="top" align="right"></td>
  </tr></table></div>
  </td>
  <td valign="top" align="right"></td>
  </tr></table></div>
-<div class="refsynopsisdiv" title="Synopsis">
+<div class="refsynopsisdiv">
  <a name="glib-Memory-Allocation.synopsis"></a><h2>Synopsis</h2>
  <pre class="synopsis">
  #include &lt;glib.h&gt;
  
  <a name="glib-Memory-Allocation.synopsis"></a><h2>Synopsis</h2>
  <pre class="synopsis">
  #include &lt;glib.h&gt;
  
-#define             <a class="link" href="glib-Memory-Allocation.html#g-new" title="g_new()">g_new</a>                               (struct_type, n_structs)
-#define             <a class="link" href="glib-Memory-Allocation.html#g-new0" title="g_new0()">g_new0</a>                              (struct_type, n_structs)
-#define             <a class="link" href="glib-Memory-Allocation.html#g-renew" title="g_renew()">g_renew</a>                             (struct_type, mem, n_structs)
-#define             <a class="link" href="glib-Memory-Allocation.html#g-try-new" title="g_try_new()">g_try_new</a>                           (struct_type, n_structs)
-#define             <a class="link" href="glib-Memory-Allocation.html#g-try-new0" title="g_try_new0()">g_try_new0</a>                          (struct_type, n_structs)
-#define             <a class="link" href="glib-Memory-Allocation.html#g-try-renew" title="g_try_renew()">g_try_renew</a>                         (struct_type, mem, n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-new" title="g_new()">g_new</a>                               (struct_type,
+                                                         n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-new0" title="g_new0()">g_new0</a>                              (struct_type,
+                                                         n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-renew" title="g_renew()">g_renew</a>                             (struct_type,
+                                                         mem,
+                                                         n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-try-new" title="g_try_new()">g_try_new</a>                           (struct_type,
+                                                         n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-try-new0" title="g_try_new0()">g_try_new0</a>                          (struct_type,
+                                                         n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-try-renew" title="g_try_renew()">g_try_renew</a>                         (struct_type,
+                                                         mem,
+                                                         n_structs)
  
  
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()">g_malloc</a>                            (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()">g_malloc0</a>                           (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()">g_realloc</a>                           (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc" title="g_try_malloc ()">g_try_malloc</a>                        (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc0" title="g_try_malloc0 ()">g_try_malloc0</a>                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-realloc" title="g_try_realloc ()">g_try_realloc</a>                       (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc-n" title="g_malloc_n ()">g_malloc_n</a>                          (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc0-n" title="g_malloc0_n ()">g_malloc0_n</a>                         (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-realloc-n" title="g_realloc_n ()">g_realloc_n</a>                         (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc-n" title="g_try_malloc_n ()">g_try_malloc_n</a>                      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc0-n" title="g_try_malloc0_n ()">g_try_malloc0_n</a>                     (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-realloc-n" title="g_try_realloc_n ()">g_try_realloc_n</a>                     (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()">g_malloc</a>                            (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()">g_malloc0</a>                           (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()">g_realloc</a>                           (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc" title="g_try_malloc ()">g_try_malloc</a>                        (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc0" title="g_try_malloc0 ()">g_try_malloc0</a>                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-realloc" title="g_try_realloc ()">g_try_realloc</a>                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc-n" title="g_malloc_n ()">g_malloc_n</a>                          (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-malloc0-n" title="g_malloc0_n ()">g_malloc0_n</a>                         (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-realloc-n" title="g_realloc_n ()">g_realloc_n</a>                         (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc-n" title="g_try_malloc_n ()">g_try_malloc_n</a>                      (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-malloc0-n" title="g_try_malloc0_n ()">g_try_malloc0_n</a>                     (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-try-realloc-n" title="g_try_realloc_n ()">g_try_realloc_n</a>                     (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);
  
  
-<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()">g_free</a>                              (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem);
-extern              gboolean <a class="link" href="glib-Memory-Allocation.html#g-mem-gc-friendly" title="g_mem_gc_friendly">g_mem_gc_friendly</a>;
+<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()">g_free</a>                              (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>);
+extern gboolean     <a class="link" href="glib-Memory-Allocation.html#g-mem-gc-friendly" title="g_mem_gc_friendly">g_mem_gc_friendly</a>;
  
  #define             <a class="link" href="glib-Memory-Allocation.html#g-alloca" title="g_alloca()">g_alloca</a>                            (size)
  
  #define             <a class="link" href="glib-Memory-Allocation.html#g-alloca" title="g_alloca()">g_alloca</a>                            (size)
-#define             <a class="link" href="glib-Memory-Allocation.html#g-newa" title="g_newa()">g_newa</a>                              (struct_type, n_structs)
+#define             <a class="link" href="glib-Memory-Allocation.html#g-newa" title="g_newa()">g_newa</a>                              (struct_type,
+                                                         n_structs)
  
  
-#define             <a class="link" href="glib-Memory-Allocation.html#g-memmove" title="g_memmove()">g_memmove</a>                           (dest,src,len)
-<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-memdup" title="g_memdup ()">g_memdup</a>                            (<a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="returnvalue">gconstpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a> byte_size);
+#define             <a class="link" href="glib-Memory-Allocation.html#g-memmove" title="g_memmove()">g_memmove</a>                           (dest,
+                                                         src,
+                                                         len)
+<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-memdup" title="g_memdup ()">g_memdup</a>                            (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> byte_size</code></em>);
  
  
-                    <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="GMemVTable">GMemVTable</a>;
-<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()">g_mem_set_vtable</a>                    (<a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="GMemVTable"><span class="returnvalue">GMemVTable</span></a> *vtable);
-<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-mem-is-system-malloc" title="g_mem_is_system_malloc ()">g_mem_is_system_malloc</a>              (void);
+struct              <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="struct GMemVTable">GMemVTable</a>;
+<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()">g_mem_set_vtable</a>                    (<em class="parameter"><code><a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="struct GMemVTable"><span class="type">GMemVTable</span></a> *vtable</code></em>);
+<a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            <a class="link" href="glib-Memory-Allocation.html#g-mem-is-system-malloc" title="g_mem_is_system_malloc ()">g_mem_is_system_malloc</a>              (<em class="parameter"><code><span class="type">void</span></code></em>);
  
  
-extern              GMemVTable *<a class="link" href="glib-Memory-Allocation.html#glib-mem-profiler-table" title="glib_mem_profiler_table">glib_mem_profiler_table</a>;
-<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Allocation.html#g-mem-profile" title="g_mem_profile ()">g_mem_profile</a>                       (void);
+extern GMemVTable      * <a class="link" href="glib-Memory-Allocation.html#glib-mem-profiler-table" title="glib_mem_profiler_table">glib_mem_profiler_table</a>;
+<span class="returnvalue">void</span>                <a class="link" href="glib-Memory-Allocation.html#g-mem-profile" title="g_mem_profile ()">g_mem_profile</a>                       (<em class="parameter"><code><span class="type">void</span></code></em>);
  </pre>
  </div>
  </pre>
  </div>
-<div class="refsect1" title="Description">
+<div class="refsect1">
  <a name="glib-Memory-Allocation.description"></a><h2>Description</h2>
  <p>
  These functions provide support for allocating and freeing memory.
  </p>
  <a name="glib-Memory-Allocation.description"></a><h2>Description</h2>
  <p>
  These functions provide support for allocating and freeing memory.
  </p>
-<div class="note" title="Note" style="margin-left: 0.5in; margin-right: 0.5in;">
-<h3 class="title">Note</h3>
  <p>
  <p>
+</p>
+<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
+<h3 class="title">Note</h3>
  If any call to allocate memory fails, the application is terminated.
  This also means that there is no need to check if the call succeeded.
  If any call to allocate memory fails, the application is terminated.
  This also means that there is no need to check if the call succeeded.
-</p>
  </div>
  </div>
-<div class="note" title="Note" style="margin-left: 0.5in; margin-right: 0.5in;">
-<h3 class="title">Note</h3>
  <p>
  <p>
+</p>
+<p>
+</p>
+<div class="note" style="margin-left: 0.5in; margin-right: 0.5in;">
+<h3 class="title">Note</h3>
  It's important to match <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> with <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a>, plain <code class="function">malloc()</code> with <code class="function">free()</code>,
  and (if you're using C++) new with delete and new[] with delete[]. Otherwise
  bad things can happen, since these allocators may use different memory
  pools (and new/delete call constructors and destructors). See also
  <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()"><code class="function">g_mem_set_vtable()</code></a>.
  It's important to match <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> with <a class="link" href="glib-Memory-Allocation.html#g-free" title="g_free ()"><code class="function">g_free()</code></a>, plain <code class="function">malloc()</code> with <code class="function">free()</code>,
  and (if you're using C++) new with delete and new[] with delete[]. Otherwise
  bad things can happen, since these allocators may use different memory
  pools (and new/delete call constructors and destructors). See also
  <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()"><code class="function">g_mem_set_vtable()</code></a>.
-</p>
  </div>
  </div>
+<p>
+</p>
  </div>
  </div>
-<div class="refsect1" title="Details">
+<div class="refsect1">
  <a name="glib-Memory-Allocation.details"></a><h2>Details</h2>
  <a name="glib-Memory-Allocation.details"></a><h2>Details</h2>
-<div class="refsect2" title="g_new()">
+<div class="refsect2">
  <a name="g-new"></a><h3>g_new()</h3>
  <pre class="programlisting">#define             g_new(struct_type, n_structs)</pre>
  <p>
  <a name="g-new"></a><h3>g_new()</h3>
  <pre class="programlisting">#define             g_new(struct_type, n_structs)</pre>
  <p>
@@ -152,13 +147,11 @@ so might hide memory allocation errors.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>the type of the elements to allocate
-</td>
+<td>the type of the elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>the number of elements to allocate
-</td>
+<td>the number of elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -169,7 +162,7 @@ so might hide memory allocation errors.
  </table></div>
  </div>
  <hr>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_new0()">
+<div class="refsect2">
  <a name="g-new0"></a><h3>g_new0()</h3>
  <pre class="programlisting">#define             g_new0(struct_type, n_structs)</pre>
  <p>
  <a name="g-new0"></a><h3>g_new0()</h3>
  <pre class="programlisting">#define             g_new0(struct_type, n_structs)</pre>
  <p>
@@ -188,24 +181,21 @@ so might hide memory allocation errors.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>the type of the elements to allocate.
-</td>
+<td>the type of the elements to allocate.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>the number of elements to allocate.
-</td>
+<td>the number of elements to allocate.</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated memory, cast to a pointer to <em class="parameter"><code>struct_type</code></em>.
-</td>
+<td>a pointer to the allocated memory, cast to a pointer to <em class="parameter"><code>struct_type</code></em>.</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_renew()">
+<div class="refsect2">
  <a name="g-renew"></a><h3>g_renew()</h3>
  <pre class="programlisting">#define             g_renew(struct_type, mem, n_structs)</pre>
  <p>
  <a name="g-renew"></a><h3>g_renew()</h3>
  <pre class="programlisting">#define             g_renew(struct_type, mem, n_structs)</pre>
  <p>
@@ -219,18 +209,15 @@ Care is taken to avoid overflow when calculating the size of the allocated block
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>the type of the elements to allocate
-</td>
+<td>the type of the elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>the currently allocated memory
-</td>
+<td>the currently allocated memory</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>the number of elements to allocate
-</td>
+<td>the number of elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -241,7 +228,7 @@ Care is taken to avoid overflow when calculating the size of the allocated block
  </table></div>
  </div>
  <hr>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_try_new()">
+<div class="refsect2">
  <a name="g-try-new"></a><h3>g_try_new()</h3>
  <pre class="programlisting">#define             g_try_new(struct_type, n_structs)</pre>
  <p>
  <a name="g-try-new"></a><h3>g_try_new()</h3>
  <pre class="programlisting">#define             g_try_new(struct_type, n_structs)</pre>
  <p>
@@ -255,13 +242,11 @@ The function returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS"
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>the type of the elements to allocate
-</td>
+<td>the type of the elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>the number of elements to allocate
-</td>
+<td>the number of elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -273,7 +258,7 @@ The function returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS"
  <p class="since">Since 2.8</p>
  </div>
  <hr>
  <p class="since">Since 2.8</p>
  </div>
  <hr>
-<div class="refsect2" title="g_try_new0()">
+<div class="refsect2">
  <a name="g-try-new0"></a><h3>g_try_new0()</h3>
  <pre class="programlisting">#define             g_try_new0(struct_type, n_structs)</pre>
  <p>
  <a name="g-try-new0"></a><h3>g_try_new0()</h3>
  <pre class="programlisting">#define             g_try_new0(struct_type, n_structs)</pre>
  <p>
@@ -288,13 +273,11 @@ The function returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS"
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>the type of the elements to allocate
-</td>
+<td>the type of the elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>the number of elements to allocate
-</td>
+<td>the number of elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -306,7 +289,7 @@ The function returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS"
  <p class="since">Since 2.8</p>
  </div>
  <hr>
  <p class="since">Since 2.8</p>
  </div>
  <hr>
-<div class="refsect2" title="g_try_renew()">
+<div class="refsect2">
  <a name="g-try-renew"></a><h3>g_try_renew()</h3>
  <pre class="programlisting">#define             g_try_renew(struct_type, mem, n_structs)</pre>
  <p>
  <a name="g-try-renew"></a><h3>g_try_renew()</h3>
  <pre class="programlisting">#define             g_try_renew(struct_type, mem, n_structs)</pre>
  <p>
@@ -321,18 +304,15 @@ The function returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS"
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>the type of the elements to allocate
-</td>
+<td>the type of the elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>the currently allocated memory
-</td>
+<td>the currently allocated memory</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>the number of elements to allocate
-</td>
+<td>the number of elements to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -344,9 +324,9 @@ The function returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS"
  <p class="since">Since 2.8</p>
  </div>
  <hr>
  <p class="since">Since 2.8</p>
  </div>
  <hr>
-<div class="refsect2" title="g_malloc ()">
+<div class="refsect2">
  <a name="g-malloc"></a><h3>g_malloc ()</h3>
  <a name="g-malloc"></a><h3>g_malloc ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc                            (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc                            (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);</pre>
  <p>
  Allocates <em class="parameter"><code>n_bytes</code></em> bytes of memory.
  If <em class="parameter"><code>n_bytes</code></em> is 0 it returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
  <p>
  Allocates <em class="parameter"><code>n_bytes</code></em> bytes of memory.
  If <em class="parameter"><code>n_bytes</code></em> is 0 it returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
@@ -356,21 +336,19 @@ If <em class="parameter"><code>n_bytes</code></em> is 0 it returns <a class="lin
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
-<td>the number of bytes to allocate
-</td>
+<td>the number of bytes to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated memory
-</td>
+<td>a pointer to the allocated memory</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_malloc0 ()">
+<div class="refsect2">
  <a name="g-malloc0"></a><h3>g_malloc0 ()</h3>
  <a name="g-malloc0"></a><h3>g_malloc0 ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc0                           (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc0                           (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);</pre>
  <p>
  Allocates <em class="parameter"><code>n_bytes</code></em> bytes of memory, initialized to 0's.
  If <em class="parameter"><code>n_bytes</code></em> is 0 it returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
  <p>
  Allocates <em class="parameter"><code>n_bytes</code></em> bytes of memory, initialized to 0's.
  If <em class="parameter"><code>n_bytes</code></em> is 0 it returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
@@ -380,22 +358,20 @@ If <em class="parameter"><code>n_bytes</code></em> is 0 it returns <a class="lin
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
-<td>the number of bytes to allocate
-</td>
+<td>the number of bytes to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated memory
-</td>
+<td>a pointer to the allocated memory</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_realloc ()">
+<div class="refsect2">
  <a name="g-realloc"></a><h3>g_realloc ()</h3>
  <a name="g-realloc"></a><h3>g_realloc ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_realloc                           (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_realloc                           (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);</pre>
  <p>
  Reallocates the memory pointed to by <em class="parameter"><code>mem</code></em>, so that it now has space for
  <em class="parameter"><code>n_bytes</code></em> bytes of memory. It returns the new address of the memory, which may
  <p>
  Reallocates the memory pointed to by <em class="parameter"><code>mem</code></em>, so that it now has space for
  <em class="parameter"><code>n_bytes</code></em> bytes of memory. It returns the new address of the memory, which may
@@ -408,26 +384,23 @@ and <em class="parameter"><code>mem</code></em> will be freed unless it is <a cl
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>the memory to reallocate
-</td>
+<td>the memory to reallocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
-<td>new size of the memory in bytes
-</td>
+<td>new size of the memory in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the new address of the allocated memory
-</td>
+<td>the new address of the allocated memory</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_try_malloc ()">
+<div class="refsect2">
  <a name="g-try-malloc"></a><h3>g_try_malloc ()</h3>
  <a name="g-try-malloc"></a><h3>g_try_malloc ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc                        (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc                        (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);</pre>
  <p>
  Attempts to allocate <em class="parameter"><code>n_bytes</code></em>, and returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> on failure.
  Contrast with <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>, which aborts the program on failure.
  <p>
  Attempts to allocate <em class="parameter"><code>n_bytes</code></em>, and returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> on failure.
  Contrast with <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>, which aborts the program on failure.
@@ -437,21 +410,19 @@ Contrast with <a class="link" href="glib-Memory-Allocation.html#g-malloc" title=
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
-<td>number of bytes to allocate.
-</td>
+<td>number of bytes to allocate.</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
-</td>
+<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_try_malloc0 ()">
+<div class="refsect2">
  <a name="g-try-malloc0"></a><h3>g_try_malloc0 ()</h3>
  <a name="g-try-malloc0"></a><h3>g_try_malloc0 ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc0                       (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc0                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);</pre>
  <p>
  Attempts to allocate <em class="parameter"><code>n_bytes</code></em>, initialized to 0's, and returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> on
  failure. Contrast with <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()"><code class="function">g_malloc0()</code></a>, which aborts the program on failure.
  <p>
  Attempts to allocate <em class="parameter"><code>n_bytes</code></em>, initialized to 0's, and returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> on
  failure. Contrast with <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()"><code class="function">g_malloc0()</code></a>, which aborts the program on failure.
@@ -461,8 +432,7 @@ failure. Contrast with <a class="link" href="glib-Memory-Allocation.html#g-mallo
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
-<td>number of bytes to allocate
-</td>
+<td>number of bytes to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -474,10 +444,10 @@ failure. Contrast with <a class="link" href="glib-Memory-Allocation.html#g-mallo
  <p class="since">Since 2.8</p>
  </div>
  <hr>
  <p class="since">Since 2.8</p>
  </div>
  <hr>
-<div class="refsect2" title="g_try_realloc ()">
+<div class="refsect2">
  <a name="g-try-realloc"></a><h3>g_try_realloc ()</h3>
  <a name="g-try-realloc"></a><h3>g_try_realloc ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_realloc                       (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_realloc                       (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_bytes</code></em>);</pre>
  <p>
  Attempts to realloc <em class="parameter"><code>mem</code></em> to a new size, <em class="parameter"><code>n_bytes</code></em>, and returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
  on failure. Contrast with <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()"><code class="function">g_realloc()</code></a>, which aborts the program
  <p>
  Attempts to realloc <em class="parameter"><code>mem</code></em> to a new size, <em class="parameter"><code>n_bytes</code></em>, and returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>
  on failure. Contrast with <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()"><code class="function">g_realloc()</code></a>, which aborts the program
@@ -488,27 +458,25 @@ on failure. If <em class="parameter"><code>mem</code></em> is <a class="link" hr
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>previously-allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
+<td>previously-allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>. <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>n_bytes</code></em> :</span></p></td>
  </td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_bytes</code></em> :</span></p></td>
-<td>number of bytes to allocate.
-</td>
+<td>number of bytes to allocate.</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
-</td>
+<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_malloc_n ()">
+<div class="refsect2">
  <a name="g-malloc-n"></a><h3>g_malloc_n ()</h3>
  <a name="g-malloc-n"></a><h3>g_malloc_n ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc_n                          (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc_n                          (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);</pre>
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
@@ -518,28 +486,25 @@ but care is taken to detect possible overflow during multiplication.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
-<td>the number of blocks to allocate
-</td>
+<td>the number of blocks to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
-<td>the size of each block in bytes
-</td>
+<td>the size of each block in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated memory
-</td>
+<td>a pointer to the allocated memory</td>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
-<div class="refsect2" title="g_malloc0_n ()">
+<div class="refsect2">
  <a name="g-malloc0-n"></a><h3>g_malloc0_n ()</h3>
  <a name="g-malloc0-n"></a><h3>g_malloc0_n ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc0_n                         (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_malloc0_n                         (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);</pre>
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()"><code class="function">g_malloc0()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-malloc0" title="g_malloc0 ()"><code class="function">g_malloc0()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
@@ -549,29 +514,26 @@ but care is taken to detect possible overflow during multiplication.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
-<td>the number of blocks to allocate
-</td>
+<td>the number of blocks to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
-<td>the size of each block in bytes
-</td>
+<td>the size of each block in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>a pointer to the allocated memory
-</td>
+<td>a pointer to the allocated memory</td>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
-<div class="refsect2" title="g_realloc_n ()">
+<div class="refsect2">
  <a name="g-realloc-n"></a><h3>g_realloc_n ()</h3>
  <a name="g-realloc-n"></a><h3>g_realloc_n ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_realloc_n                         (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_realloc_n                         (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);</pre>
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()"><code class="function">g_realloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-realloc" title="g_realloc ()"><code class="function">g_realloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
@@ -581,33 +543,29 @@ but care is taken to detect possible overflow during multiplication.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>the memory to reallocate
-</td>
+<td>the memory to reallocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
-<td>the number of blocks to allocate
-</td>
+<td>the number of blocks to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
-<td>the size of each block in bytes
-</td>
+<td>the size of each block in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the new address of the allocated memory
-</td>
+<td>the new address of the allocated memory</td>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
-<div class="refsect2" title="g_try_malloc_n ()">
+<div class="refsect2">
  <a name="g-try-malloc-n"></a><h3>g_try_malloc_n ()</h3>
  <a name="g-try-malloc-n"></a><h3>g_try_malloc_n ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc_n                      (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc_n                      (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);</pre>
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-try-malloc" title="g_try_malloc ()"><code class="function">g_try_malloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-try-malloc" title="g_try_malloc ()"><code class="function">g_try_malloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
@@ -617,28 +575,25 @@ but care is taken to detect possible overflow during multiplication.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
-<td>the number of blocks to allocate
-</td>
+<td>the number of blocks to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
-<td>the size of each block in bytes
-</td>
+<td>the size of each block in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
-</td>
+<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</td>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
-<div class="refsect2" title="g_try_malloc0_n ()">
+<div class="refsect2">
  <a name="g-try-malloc0-n"></a><h3>g_try_malloc0_n ()</h3>
  <a name="g-try-malloc0-n"></a><h3>g_try_malloc0_n ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc0_n                     (<a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_malloc0_n                     (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);</pre>
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-try-malloc0" title="g_try_malloc0 ()"><code class="function">g_try_malloc0()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-try-malloc0" title="g_try_malloc0 ()"><code class="function">g_try_malloc0()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
@@ -648,13 +603,11 @@ but care is taken to detect possible overflow during multiplication.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
-<td>the number of blocks to allocate
-</td>
+<td>the number of blocks to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
-<td>the size of each block in bytes
-</td>
+<td>the size of each block in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
@@ -666,11 +619,11 @@ but care is taken to detect possible overflow during multiplication.
  <p class="since">Since 2.24</p>
  </div>
  <hr>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
-<div class="refsect2" title="g_try_realloc_n ()">
+<div class="refsect2">
  <a name="g-try-realloc-n"></a><h3>g_try_realloc_n ()</h3>
  <a name="g-try-realloc-n"></a><h3>g_try_realloc_n ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_realloc_n                     (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_blocks,
-                                                         <a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="returnvalue">gsize</span></a> n_block_bytes);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_try_realloc_n                     (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_blocks</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gsize" title="gsize"><span class="type">gsize</span></a> n_block_bytes</code></em>);</pre>
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-try-realloc" title="g_try_realloc ()"><code class="function">g_try_realloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
  <p>
  This function is similar to <a class="link" href="glib-Memory-Allocation.html#g-try-realloc" title="g_try_realloc ()"><code class="function">g_try_realloc()</code></a>, allocating (<em class="parameter"><code>n_blocks</code></em> * <em class="parameter"><code>n_block_bytes</code></em>) bytes,
  but care is taken to detect possible overflow during multiplication.
@@ -680,32 +633,29 @@ but care is taken to detect possible overflow during multiplication.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>previously-allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
+<td>previously-allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>. <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>n_blocks</code></em> :</span></p></td>
  </td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_blocks</code></em> :</span></p></td>
-<td>the number of blocks to allocate
-</td>
+<td>the number of blocks to allocate</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_block_bytes</code></em> :</span></p></td>
-<td>the size of each block in bytes
-</td>
+<td>the size of each block in bytes</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
-</td>
+<td>the allocated memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</td>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  <p class="since">Since 2.24</p>
  </div>
  <hr>
-<div class="refsect2" title="g_free ()">
+<div class="refsect2">
  <a name="g-free"></a><h3>g_free ()</h3>
  <a name="g-free"></a><h3>g_free ()</h3>
-<pre class="programlisting"><span class="returnvalue">void</span>                g_free                              (<a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a> mem);</pre>
+<pre class="programlisting"><span class="returnvalue">void</span>                g_free                              (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="type">gpointer</span></a> mem</code></em>);</pre>
  <p>
  Frees the memory pointed to by <em class="parameter"><code>mem</code></em>.
  If <em class="parameter"><code>mem</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> it simply returns.
  <p>
  Frees the memory pointed to by <em class="parameter"><code>mem</code></em>.
  If <em class="parameter"><code>mem</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> it simply returns.
@@ -714,23 +664,22 @@ If <em class="parameter"><code>mem</code></em> is <a class="link" href="glib-Sta
  <col align="left" valign="top">
  <tbody><tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  <col align="left" valign="top">
  <tbody><tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>the memory to free
-</td>
+<td>the memory to free</td>
  </tr></tbody>
  </table></div>
  </div>
  <hr>
  </tr></tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_mem_gc_friendly">
+<div class="refsect2">
  <a name="g-mem-gc-friendly"></a><h3>g_mem_gc_friendly</h3>
  <pre class="programlisting">extern gboolean g_mem_gc_friendly;
  </pre>
  <p>
  This variable is <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the <code class="envar">G_DEBUG</code> environment variable
  <a name="g-mem-gc-friendly"></a><h3>g_mem_gc_friendly</h3>
  <pre class="programlisting">extern gboolean g_mem_gc_friendly;
  </pre>
  <p>
  This variable is <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> if the <code class="envar">G_DEBUG</code> environment variable
-includes the key <a class="link" href="glib-running.html#G_DEBUG" title="G_DEBUG">gc-friendly</a>.
+includes the key <code class="literal">gc-friendly</code>.
  </p>
  </div>
  <hr>
  </p>
  </div>
  <hr>
-<div class="refsect2" title="g_alloca()">
+<div class="refsect2">
  <a name="g-alloca"></a><h3>g_alloca()</h3>
  <pre class="programlisting">#define             g_alloca(size)</pre>
  <p>
  <a name="g-alloca"></a><h3>g_alloca()</h3>
  <pre class="programlisting">#define             g_alloca(size)</pre>
  <p>
@@ -791,19 +740,17 @@ Thus it provides the same advantages and pitfalls as <code class="function">allo
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>size</code></em> :</span></p></td>
-<td>   number of bytes to allocate.
-</td>
+<td>number of bytes to allocate.</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>space for <em class="parameter"><code>size</code></em> bytes, allocated on the stack
-</td>
+<td>space for <em class="parameter"><code>size</code></em> bytes, allocated on the stack</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_newa()">
+<div class="refsect2">
  <a name="g-newa"></a><h3>g_newa()</h3>
  <pre class="programlisting">#define             g_newa(struct_type, n_structs)</pre>
  <p>
  <a name="g-newa"></a><h3>g_newa()</h3>
  <pre class="programlisting">#define             g_newa(struct_type, n_structs)</pre>
  <p>
@@ -814,24 +761,22 @@ Wraps <a class="link" href="glib-Memory-Allocation.html#g-alloca" title="g_alloc
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>struct_type</code></em> :</span></p></td>
-<td>Type of memory chunks to be allocated
-</td>
+<td>Type of memory chunks to be allocated</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>n_structs</code></em> :</span></p></td>
-<td>  Number of chunks to be allocated
-</td>
+<td>Number of chunks to be allocated</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td>    Pointer to stack space for <em class="parameter"><code>n_structs</code></em> chunks of type <em class="parameter"><code>struct_type</code></em>
+<td>Pointer to stack space for <em class="parameter"><code>n_structs</code></em> chunks of type <em class="parameter"><code>struct_type</code></em>
  </td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_memmove()">
+<div class="refsect2">
  <a name="g-memmove"></a><h3>g_memmove()</h3>
  <pre class="programlisting">#define             g_memmove(dest,src,len)</pre>
  <p>
  <a name="g-memmove"></a><h3>g_memmove()</h3>
  <pre class="programlisting">#define             g_memmove(dest,src,len)</pre>
  <p>
@@ -842,33 +787,31 @@ The source and destination areas may overlap.
  In order to use this function, you must include 
  <code class="filename">string.h</code> yourself, because this macro will 
  typically simply resolve to <code class="function">memmove()</code> and GLib does not include 
  In order to use this function, you must include 
  <code class="filename">string.h</code> yourself, because this macro will 
  typically simply resolve to <code class="function">memmove()</code> and GLib does not include 
-<code class="filename">string.h</code> for you.</p>
+<code class="filename">string.h</code> for you.
+</p>
  <div class="variablelist"><table border="0">
  <col align="left" valign="top">
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>dest</code></em> :</span></p></td>
  <div class="variablelist"><table border="0">
  <col align="left" valign="top">
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>dest</code></em> :</span></p></td>
-<td> the destination address to copy the bytes to.
-</td>
+<td>the destination address to copy the bytes to.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>src</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>src</code></em> :</span></p></td>
-<td> the source address to copy the bytes from.
-</td>
+<td>the source address to copy the bytes from.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>len</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>len</code></em> :</span></p></td>
-<td> the number of bytes to copy.
-</td>
+<td>the number of bytes to copy.</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_memdup ()">
+<div class="refsect2">
  <a name="g-memdup"></a><h3>g_memdup ()</h3>
  <a name="g-memdup"></a><h3>g_memdup ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_memdup                            (<a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="returnvalue">gconstpointer</span></a> mem,
-                                                         <a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="returnvalue">guint</span></a> byte_size);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gpointer" title="gpointer"><span class="returnvalue">gpointer</span></a>            g_memdup                            (<em class="parameter"><code><a class="link" href="glib-Basic-Types.html#gconstpointer" title="gconstpointer"><span class="type">gconstpointer</span></a> mem</code></em>,
+                                                         <em class="parameter"><code><a class="link" href="glib-Basic-Types.html#guint" title="guint"><span class="type">guint</span></a> byte_size</code></em>);</pre>
  <p>
  Allocates <em class="parameter"><code>byte_size</code></em> bytes of memory, and copies <em class="parameter"><code>byte_size</code></em> bytes into it
  from <em class="parameter"><code>mem</code></em>. If <em class="parameter"><code>mem</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> it returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
  <p>
  Allocates <em class="parameter"><code>byte_size</code></em> bytes of memory, and copies <em class="parameter"><code>byte_size</code></em> bytes into it
  from <em class="parameter"><code>mem</code></em>. If <em class="parameter"><code>mem</code></em> is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> it returns <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
@@ -878,27 +821,24 @@ from <em class="parameter"><code>mem</code></em>. If <em class="parameter"><code
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>mem</code></em> :</span></p></td>
-<td>the memory to copy.
-</td>
+<td>the memory to copy.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>byte_size</code></em> :</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="parameter"><code>byte_size</code></em> :</span></p></td>
-<td>the number of bytes to copy.
-</td>
+<td>the number of bytes to copy.</td>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  <td>a pointer to the newly-allocated copy of the memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> if <em class="parameter"><code>mem</code></em>
  </tr>
  <tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  <td>a pointer to the newly-allocated copy of the memory, or <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a> if <em class="parameter"><code>mem</code></em>
-is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.
-</td>
+is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code class="literal">NULL</code></a>.</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="GMemVTable">
-<a name="GMemVTable"></a><h3>GMemVTable</h3>
-<pre class="programlisting">typedef struct {
+<div class="refsect2">
+<a name="GMemVTable"></a><h3>struct GMemVTable</h3>
+<pre class="programlisting">struct GMemVTable {
    gpointer (*malloc)      (gsize    n_bytes);
    gpointer (*realloc)     (gpointer mem,
                            gsize    n_bytes);
    gpointer (*malloc)      (gsize    n_bytes);
    gpointer (*realloc)     (gpointer mem,
                            gsize    n_bytes);
@@ -909,10 +849,10 @@ is <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="NULL"><code
    gpointer (*try_malloc)  (gsize    n_bytes);
    gpointer (*try_realloc) (gpointer mem,
                            gsize    n_bytes);
    gpointer (*try_malloc)  (gsize    n_bytes);
    gpointer (*try_realloc) (gpointer mem,
                            gsize    n_bytes);
-} GMemVTable;
+};
  </pre>
  <p>
  </pre>
  <p>
-A set of functions used to perform memory allocation. The same <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="GMemVTable"><span class="type">GMemVTable</span></a> must
+A set of functions used to perform memory allocation. The same <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="struct GMemVTable"><span class="type">GMemVTable</span></a> must
  be used for all allocations in the same program; a call to <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()"><code class="function">g_mem_set_vtable()</code></a>,
  if it exists, should be prior to any use of GLib.
  </p>
  be used for all allocations in the same program; a call to <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()"><code class="function">g_mem_set_vtable()</code></a>,
  if it exists, should be prior to any use of GLib.
  </p>
@@ -921,43 +861,37 @@ if it exists, should be prior to any use of GLib.
  <tbody>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.malloc"></a>malloc</code></em> ()</span></p></td>
  <tbody>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.malloc"></a>malloc</code></em> ()</span></p></td>
-<td>function to use for allocating memory.
-</td>
+<td>function to use for allocating memory.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.realloc"></a>realloc</code></em> ()</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.realloc"></a>realloc</code></em> ()</span></p></td>
-<td>function to use for reallocating memory.
-</td>
+<td>function to use for reallocating memory.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.free"></a>free</code></em> ()</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.free"></a>free</code></em> ()</span></p></td>
-<td>function to use to free memory.
-</td>
+<td>function to use to free memory.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.calloc"></a>calloc</code></em> ()</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.calloc"></a>calloc</code></em> ()</span></p></td>
-<td>function to use for allocating zero-filled memory.
-</td>
+<td>function to use for allocating zero-filled memory.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.try-malloc"></a>try_malloc</code></em> ()</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.try-malloc"></a>try_malloc</code></em> ()</span></p></td>
-<td>function to use for allocating memory without a default error handler.
-</td>
+<td>function to use for allocating memory without a default error handler.</td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.try-realloc"></a>try_realloc</code></em> ()</span></p></td>
  </tr>
  <tr>
  <td><p><span class="term"><em class="structfield"><code><a name="GMemVTable.try-realloc"></a>try_realloc</code></em> ()</span></p></td>
-<td>function to use for reallocating memory without a default error handler.
-</td>
+<td>function to use for reallocating memory without a default error handler.</td>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
  </tr>
  </tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_mem_set_vtable ()">
+<div class="refsect2">
  <a name="g-mem-set-vtable"></a><h3>g_mem_set_vtable ()</h3>
  <a name="g-mem-set-vtable"></a><h3>g_mem_set_vtable ()</h3>
-<pre class="programlisting"><span class="returnvalue">void</span>                g_mem_set_vtable                    (<a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="GMemVTable"><span class="returnvalue">GMemVTable</span></a> *vtable);</pre>
+<pre class="programlisting"><span class="returnvalue">void</span>                g_mem_set_vtable                    (<em class="parameter"><code><a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="struct GMemVTable"><span class="type">GMemVTable</span></a> *vtable</code></em>);</pre>
  <p>
  <p>
-Sets the <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="GMemVTable"><span class="type">GMemVTable</span></a> to use for memory allocation. You can use this to provide
+Sets the <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="struct GMemVTable"><span class="type">GMemVTable</span></a> to use for memory allocation. You can use this to provide
  custom memory allocation routines. <span class="emphasis"><em>This function must be called
  before using any other GLib functions.</em></span> The <em class="parameter"><code>vtable</code></em> only needs to
  provide <code class="function">malloc()</code>, <code class="function">realloc()</code>, and <code class="function">free()</code> functions; GLib can provide default
  custom memory allocation routines. <span class="emphasis"><em>This function must be called
  before using any other GLib functions.</em></span> The <em class="parameter"><code>vtable</code></em> only needs to
  provide <code class="function">malloc()</code>, <code class="function">realloc()</code>, and <code class="function">free()</code> functions; GLib can provide default
@@ -969,49 +903,48 @@ should return <a class="link" href="glib-Standard-Macros.html#NULL:CAPS" title="
  <col align="left" valign="top">
  <tbody><tr>
  <td><p><span class="term"><em class="parameter"><code>vtable</code></em> :</span></p></td>
  <col align="left" valign="top">
  <tbody><tr>
  <td><p><span class="term"><em class="parameter"><code>vtable</code></em> :</span></p></td>
-<td>table of memory allocation routines.
-</td>
+<td>table of memory allocation routines.</td>
  </tr></tbody>
  </table></div>
  </div>
  <hr>
  </tr></tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="g_mem_is_system_malloc ()">
+<div class="refsect2">
  <a name="g-mem-is-system-malloc"></a><h3>g_mem_is_system_malloc ()</h3>
  <a name="g-mem-is-system-malloc"></a><h3>g_mem_is_system_malloc ()</h3>
-<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_mem_is_system_malloc              (void);</pre>
+<pre class="programlisting"><a class="link" href="glib-Basic-Types.html#gboolean" title="gboolean"><span class="returnvalue">gboolean</span></a>            g_mem_is_system_malloc              (<em class="parameter"><code><span class="type">void</span></code></em>);</pre>
  <p>
  Checks whether the allocator used by <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> is the system's
  malloc implementation. If it returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> memory allocated with
  <p>
  Checks whether the allocator used by <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> is the system's
  malloc implementation. If it returns <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a> memory allocated with
-<code class="function">malloc()</code> can be used interchangeable with memory allocated using <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>. 
+<code class="function">malloc()</code> can be used interchangeable with memory allocated using <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a>.
  This function is useful for avoiding an extra copy of allocated memory returned
  by a non-GLib-based API.
  </p>
  <p>
  This function is useful for avoiding an extra copy of allocated memory returned
  by a non-GLib-based API.
  </p>
  <p>
-A different allocator can be set using <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()"><code class="function">g_mem_set_vtable()</code></a>.</p>
+A different allocator can be set using <a class="link" href="glib-Memory-Allocation.html#g-mem-set-vtable" title="g_mem_set_vtable ()"><code class="function">g_mem_set_vtable()</code></a>.
+</p>
  <div class="variablelist"><table border="0">
  <col align="left" valign="top">
  <tbody><tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
  <div class="variablelist"><table border="0">
  <col align="left" valign="top">
  <tbody><tr>
  <td><p><span class="term"><span class="emphasis"><em>Returns</em></span> :</span></p></td>
-<td> if <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a>, <code class="function">malloc()</code> and <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> can be mixed.
-</td>
+<td>if <a class="link" href="glib-Standard-Macros.html#TRUE:CAPS" title="TRUE"><code class="literal">TRUE</code></a>, <code class="function">malloc()</code> and <a class="link" href="glib-Memory-Allocation.html#g-malloc" title="g_malloc ()"><code class="function">g_malloc()</code></a> can be mixed.</td>
  </tr></tbody>
  </table></div>
  </div>
  <hr>
  </tr></tbody>
  </table></div>
  </div>
  <hr>
-<div class="refsect2" title="glib_mem_profiler_table">
+<div class="refsect2">
  <a name="glib-mem-profiler-table"></a><h3>glib_mem_profiler_table</h3>
  <pre class="programlisting">extern GMemVTable *glib_mem_profiler_table;
  </pre>
  <p>
  <a name="glib-mem-profiler-table"></a><h3>glib_mem_profiler_table</h3>
  <pre class="programlisting">extern GMemVTable *glib_mem_profiler_table;
  </pre>
  <p>
-A <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="GMemVTable"><span class="type">GMemVTable</span></a> containing profiling variants of the memory
+A <a class="link" href="glib-Memory-Allocation.html#GMemVTable" title="struct GMemVTable"><span class="type">GMemVTable</span></a> containing profiling variants of the memory
  allocation functions. Use them together with <a class="link" href="glib-Memory-Allocation.html#g-mem-profile" title="g_mem_profile ()"><code class="function">g_mem_profile()</code></a>
  in order to get information about the memory allocation pattern
  of your program.
  </p>
  </div>
  <hr>
  allocation functions. Use them together with <a class="link" href="glib-Memory-Allocation.html#g-mem-profile" title="g_mem_profile ()"><code class="function">g_mem_profile()</code></a>
  in order to get information about the memory allocation pattern
  of your program.
  </p>
  </div>
  <hr>
-<div class="refsect2" title="g_mem_profile ()">
+<div class="refsect2">
  <a name="g-mem-profile"></a><h3>g_mem_profile ()</h3>
  <a name="g-mem-profile"></a><h3>g_mem_profile ()</h3>
-<pre class="programlisting"><span class="returnvalue">void</span>                g_mem_profile                       (void);</pre>
+<pre class="programlisting"><span class="returnvalue">void</span>                g_mem_profile                       (<em class="parameter"><code><span class="type">void</span></code></em>);</pre>
  <p>
  Outputs a summary of memory usage.
  </p>
  <p>
  Outputs a summary of memory usage.
  </p>
@@ -1031,6 +964,6 @@ previously installed the <a class="link" href="glib-Memory-Allocation.html#glib-
  </div>
  <div class="footer">
  <hr>
  </div>
  <div class="footer">
  <hr>
-          Generated by GTK-Doc V1.13</div>
+          Generated by GTK-Doc V1.18</div>
  </body>
  </html>
 \ No newline at end of file
  </body>
  </html>
 \ No newline at end of file