erl_interface: Remove CDATA tag except for example code

14 files changed, 1117 insertions, 1118 deletions

diff --git a/lib/erl_interface/doc/src/ei.xml b/lib/erl_interface/doc/src/ei.xml
index 9b01f4af98..ddfb4d88a8 100644
--- a/lib/erl_interface/doc/src/ei.xml
+++ b/lib/erl_interface/doc/src/ei.xml
@@ -35,24 +35,24 @@
   <lib>ei</lib>
   <libsummary>Routines for handling the Erlang binary term format.</libsummary>
   <description>
-    <p>The library <c><![CDATA[ei]]></c> contains macros and functions to encode
+    <p>The library <c>ei</c> contains macros and functions to encode
       and decode the Erlang binary term format.</p>
 
-    <p><c><![CDATA[ei]]></c> allows you to convert atoms, lists, numbers, and
+    <p><c>ei</c> allows you to convert atoms, lists, numbers, and
       binaries to and from the binary format. This is useful when
-      writing port programs and drivers. <c><![CDATA[ei]]></c> uses a given
+      writing port programs and drivers. <c>ei</c> uses a given
       buffer, no dynamic memory (except
-      <c><![CDATA[ei_decode_fun()]]></c>) and is often quite fast.</p>
+      <c>ei_decode_fun()</c>) and is often quite fast.</p>
 
-    <p><c><![CDATA[ei]]></c> also handles C-nodes, C-programs that talks Erlang
+    <p><c>ei</c> also handles C-nodes, C-programs that talks Erlang
       distribution with Erlang nodes (or other C-nodes) using the
-      Erlang distribution format. The difference between <c><![CDATA[ei]]></c>
-      and <c><![CDATA[erl_interface]]></c> is that <c><![CDATA[ei]]></c> uses
+      Erlang distribution format. The difference between <c>ei</c>
+      and <c>erl_interface</c> is that <c>ei</c> uses
       the binary format directly when sending and receiving terms. It is also
       thread safe, and using threads, one process can handle multiple
-      C-nodes. The <c><![CDATA[erl_interface]]></c> library is built on top of
-      <c><![CDATA[ei]]></c>, but of legacy reasons, it does not allow for
-      multiple C-nodes. In general, <c><![CDATA[ei]]></c> is the preferred way
+      C-nodes. The <c>erl_interface</c> library is built on top of
+      <c>ei</c>, but of legacy reasons, it does not allow for
+      multiple C-nodes. In general, <c>ei</c> is the preferred way
       of doing C-nodes.</p>
 
     <p>The decode and encode functions use a buffer and an index into the
@@ -65,37 +65,37 @@
     <p>All functions take two parameters:</p>
 
     <list type="bulleted">
-      <item><p><c><![CDATA[buf]]></c> is a pointer to
+      <item><p><c>buf</c> is a pointer to
         the buffer where the binary data is or will be.</p>
       </item>
-      <item><p><c><![CDATA[index]]></c> is a pointer to an index into the
+      <item><p><c>index</c> is a pointer to an index into the
         buffer. This parameter is incremented with the size of the term
         decoded/encoded.</p>
       </item>
     </list>
 
-    <p>The data is thus at <c><![CDATA[buf[*index]]]></c> when an
-      <c><![CDATA[ei]]></c> function is called.</p>
+    <p>The data is thus at <c>buf[*index]</c> when an
+      <c>ei</c> function is called.</p>
 
-    <p>All encode functions assume that the <c><![CDATA[buf]]></c> and
-      <c><![CDATA[index]]></c> parameters point to a buffer large enough for
+    <p>All encode functions assume that the <c>buf</c> and
+      <c>index</c> parameters point to a buffer large enough for
       the data. To get the size of an encoded term, without encoding it,
-      pass <c><![CDATA[NULL]]></c> instead of a buffer pointer. Parameter
-      <c><![CDATA[index]]></c> is incremented, but nothing will be encoded. This
-      is the way in <c><![CDATA[ei]]></c> to "preflight" term encoding.</p>
+      pass <c>NULL</c> instead of a buffer pointer. Parameter
+      <c>index</c> is incremented, but nothing will be encoded. This
+      is the way in <c>ei</c> to "preflight" term encoding.</p>
 
     <p>There are also encode functions that use a dynamic buffer. It
       is often more convenient to use these to encode data. All encode
       functions comes in two versions; those starting with
-      <c><![CDATA[ei_x]]></c> use a dynamic buffer.</p>
+      <c>ei_x</c> use a dynamic buffer.</p>
 
-    <p>All functions return <c><![CDATA[0]]></c> if successful, otherwise
-      <c><![CDATA[-1]]></c> (for example, if a term is not of the expected
+    <p>All functions return <c>0</c> if successful, otherwise
+      <c>-1</c> (for example, if a term is not of the expected
       type, or the data to decode is an invalid Erlang term).</p>
 
     <p>Some of the decode functions need a pre-allocated buffer. This
       buffer must be allocated large enough, and for non-compound types
-      the <c><![CDATA[ei_get_type()]]></c>
+      the <c>ei_get_type()</c>
       function returns the size required (notice that for strings an
       extra byte is needed for the <c>NULL</c>-terminator).</p>
   </description>
@@ -128,8 +128,8 @@ typedef enum {
           <fsummary>Decode an atom.</fsummary>
           <desc>
               <p>Decodes an atom from the binary format. The <c>NULL</c>-terminated
-                  name of the atom is placed at <c><![CDATA[p]]></c>. At most
-                  <c><![CDATA[MAXATOMLEN]]></c> bytes can be placed in the buffer.</p>
+                  name of the atom is placed at <c>p</c>. At most
+                  <c>MAXATOMLEN</c> bytes can be placed in the buffer.</p>
           </desc>
       </func>
 
@@ -162,7 +162,7 @@ typedef enum {
           <fsummary>Decode a GMP arbitrary precision integer.</fsummary>
           <desc>
               <p>Decodes an integer in the binary format to a GMP
-                  <c><![CDATA[mpz_t]]></c> integer. To use this function, the <c>ei</c>
+                  <c>mpz_t</c> integer. To use this function, the <c>ei</c>
                   library must be configured and compiled to use the GMP library.</p>
           </desc>
       </func>
@@ -172,10 +172,10 @@ typedef enum {
           <fsummary>Decode a binary.</fsummary>
           <desc>
               <p>Decodes a binary from the binary format. Parameter
-                  <c><![CDATA[len]]></c> is set to the actual size of the
-                  binary. Notice that <c><![CDATA[ei_decode_binary()]]></c> assumes that
+                  <c>len</c> is set to the actual size of the
+                  binary. Notice that <c>ei_decode_binary()</c> assumes that
                   there is enough room for the binary. The size required can be
-                  fetched by <c><![CDATA[ei_get_type()]]></c>.</p>
+                  fetched by <c>ei_get_type()</c>.</p>
           </desc>
       </func>
 
@@ -184,8 +184,8 @@ typedef enum {
           <fsummary>Decode a boolean.</fsummary>
           <desc>
               <p>Decodes a boolean value from the binary format.
-                  A boolean is actually an atom, <c><![CDATA[true]]></c> decodes 1
-                  and <c><![CDATA[false]]></c> decodes 0.</p>
+                  A boolean is actually an atom, <c>true</c> decodes 1
+                  and <c>false</c> decodes 0.</p>
           </desc>
       </func>
 
@@ -195,9 +195,9 @@ typedef enum {
           <desc>
               <p>Decodes a char (8-bit) integer between 0-255 from the binary format.
                   For historical reasons the returned integer is of
-                  type <c><![CDATA[char]]></c>. Your C code is to  consider the
-                  returned value to be of type <c><![CDATA[unsigned char]]></c> even if
-                  the C compilers and system can define <c><![CDATA[char]]></c> to be
+                  type <c>char</c>. Your C code is to  consider the
+                  returned value to be of type <c>unsigned char</c> even if
+                  the C compilers and system can define <c>char</c> to be
                   signed.</p>
           </desc>
       </func>
@@ -216,16 +216,16 @@ typedef enum {
       <fsummary>Decode a term, without previous knowledge of type.</fsummary>
       <desc>
         <p>Decodes any term, or at least tries to. If the term
-          pointed at by <c><![CDATA[*index]]></c> in <c><![CDATA[buf]]></c> fits
-          in the <c><![CDATA[term]]></c> union, it is decoded, and the
-          appropriate field in <c><![CDATA[term->value]]></c> is set, and
-          <c><![CDATA[*index]]></c> is incremented by the term size.</p>
+          pointed at by <c>*index</c> in <c>buf</c> fits
+          in the <c>term</c> union, it is decoded, and the
+          appropriate field in <c>term->value</c> is set, and
+          <c>*index</c> is incremented by the term size.</p>
         <p>The function returns <c>1</c> on successful decoding, <c>-1</c> on
           error, and <c>0</c> if the term seems alright, but does not fit in the
-          <c><![CDATA[term]]></c> structure. If <c>1</c> is returned, the
-          <c><![CDATA[index]]></c> is incremented, and <c><![CDATA[term]]></c>
+          <c>term</c> structure. If <c>1</c> is returned, the
+          <c>index</c> is incremented, and <c>term</c>
           contains the decoded term.</p>
-        <p>The <c><![CDATA[term]]></c> structure contains the arity for a tuple
+        <p>The <c>term</c> structure contains the arity for a tuple
           or list, size for a binary, string, or atom. It contains
           a term if it is any of the following: integer, float, atom,
           pid, port, or ref.</p>
@@ -238,11 +238,11 @@ typedef enum {
       <fsummary>Decode a fun.</fsummary>
       <desc>
         <p>Decodes a fun from the binary format. Parameter
-          <c><![CDATA[p]]></c> is to be <c>NULL</c> or point to an
-          <c><![CDATA[erlang_fun]]></c> structure. This is the only decode
-          function that allocates memory. When the <c><![CDATA[erlang_fun]]></c>
+          <c>p</c> is to be <c>NULL</c> or point to an
+          <c>erlang_fun</c> structure. This is the only decode
+          function that allocates memory. When the <c>erlang_fun</c>
           is no longer needed, it is to be freed with
-          <c><![CDATA[free_fun]]></c>. (This has to do with the arbitrary size
+          <c>free_fun</c>. (This has to do with the arbitrary size
           of the environment for a fun.)</p>
       </desc>
     </func>
@@ -253,13 +253,13 @@ typedef enum {
       <desc>
         <p>Decodes a list header from the binary
           format. The number of elements is returned in
-          <c><![CDATA[arity]]></c>. The <c><![CDATA[arity+1]]></c> elements
+          <c>arity</c>. The <c>arity+1</c> elements
           follow (the last one is the tail of the list, normally an empty list).
-          If <c><![CDATA[arity]]></c> is <c><![CDATA[0]]></c>, it is an empty
+          If <c>arity</c> is <c>0</c>, it is an empty
           list.</p>
         <p>Notice that lists are encoded as strings if they consist
           entirely of integers in the range 0..255. This function do
-          not decode such strings, use <c><![CDATA[ei_decode_string()]]></c>
+          not decode such strings, use <c>ei_decode_string()</c>
           instead.</p>
       </desc>
     </func>
@@ -278,8 +278,8 @@ typedef enum {
       <name><ret>int</ret><nametext>ei_decode_longlong(const char *buf, int *index, long long *p)</nametext></name>
       <fsummary>Decode integer.</fsummary>
       <desc>
-        <p>Decodes a GCC <c><![CDATA[long long]]></c> or Visual C++
-          <c><![CDATA[__int64]]></c>
+        <p>Decodes a GCC <c>long long</c> or Visual C++
+          <c>__int64</c>
           (64-bit) integer from the binary format. This
           function is missing in the VxWorks port.</p>
       </desc>
@@ -300,7 +300,7 @@ typedef enum {
 
     <func>
       <name><ret>int</ret><nametext>ei_decode_pid(const char *buf, int *index, erlang_pid *p)</nametext></name>
-      <fsummary>Decode a <c><![CDATA[pid]]></c>.</fsummary>
+      <fsummary>Decode a <c>pid</c>.</fsummary>
       <desc>
         <p>Decodes a process identifier (pid) from the binary format.</p>
       </desc>
@@ -329,9 +329,9 @@ typedef enum {
         <p>Decodes a string from the binary format. A
           string in Erlang is a list of integers between 0 and
           255. Notice that as the string is just a list, sometimes
-          lists are encoded as strings by <c><![CDATA[term_to_binary/1]]></c>,
+          lists are encoded as strings by <c>term_to_binary/1</c>,
           even if it was not intended.</p>
-        <p>The string is copied to <c><![CDATA[p]]></c>, and enough space must
+        <p>The string is copied to <c>p</c>, and enough space must
           be allocated. The returned string is <c>NULL</c>-terminated, so you
           must add an extra byte to the memory requirement.</p>
       </desc>
@@ -339,11 +339,11 @@ typedef enum {
 
     <func>
       <name><ret>int</ret><nametext>ei_decode_term(const char *buf, int *index, void *t)</nametext></name>
-      <fsummary>Decode a <c><![CDATA[ETERM]]></c>.</fsummary>
+      <fsummary>Decode a <c>ETERM</c>.</fsummary>
       <desc>
         <p>Decodes a term from the binary format. The term
-          is return in <c><![CDATA[t]]></c> as a <c><![CDATA[ETERM*]]></c>, so
-          <c><![CDATA[t]]></c> is actually an <c><![CDATA[ETERM**]]></c> (see
+          is return in <c>t</c> as a <c>ETERM*</c>, so
+          <c>t</c> is actually an <c>ETERM**</c> (see
           <seealso marker="erl_eterm"><c>erl_eterm</c></seealso>).
           The term is later to be deallocated.</p>
         <p>Notice that this function is located in the <c>Erl_Interface</c>
@@ -364,7 +364,7 @@ typedef enum {
       <fsummary>Decode a tuple.</fsummary>
       <desc>
         <p>Decodes a tuple header, the number of elements
-          is returned in <c><![CDATA[arity]]></c>. The tuple elements follow
+          is returned in <c>arity</c>. The tuple elements follow
           in order in the buffer.</p>
       </desc>
     </func>
@@ -383,15 +383,15 @@ typedef enum {
       <name><ret>int</ret><nametext>ei_decode_ulonglong(const char *buf, int *index, unsigned long long *p)</nametext></name>
       <fsummary>Decode unsigned integer.</fsummary>
       <desc>
-        <p>Decodes a GCC <c><![CDATA[unsigned long long]]></c> or Visual C++
-          <c><![CDATA[unsigned __int64]]></c> (64-bit) integer from the binary
+        <p>Decodes a GCC <c>unsigned long long</c> or Visual C++
+          <c>unsigned __int64</c> (64-bit) integer from the binary
           format. This function is missing in the VxWorks port.</p>
       </desc>
     </func>
 
     <func>
       <name><ret>int</ret><nametext>ei_decode_version(const char *buf, int *index, int *version)</nametext></name>
-      <fsummary>Decode an empty list (<c><![CDATA[nil]]></c>).</fsummary>
+      <fsummary>Decode an empty list (<c>nil</c>).</fsummary>
       <desc>
         <p>Decodes the version magic number for the
           Erlang binary term format. It must be the first token in a
@@ -406,11 +406,11 @@ typedef enum {
       <name><ret>int</ret><nametext>ei_x_encode_atom_len(ei_x_buff* x, const char *p, int len)</nametext></name>
       <fsummary>Encode an atom.</fsummary>
       <desc>
-        <p>Encodes an atom in the binary format. Parameter <c><![CDATA[p]]></c>
+        <p>Encodes an atom in the binary format. Parameter <c>p</c>
           is the name of the atom in Latin-1 encoding. Only up to
           <c>MAXATOMLEN-1</c> bytes
           are encoded. The name is to be <c>NULL</c>-terminated, except for
-          the <c><![CDATA[ei_x_encode_atom_len()]]></c> function.</p>
+          the <c>ei_x_encode_atom_len()</c> function.</p>
       </desc>
     </func>
 
@@ -445,7 +445,7 @@ typedef enum {
       <name><ret>int</ret><nametext>ei_x_encode_bignum(ei_x_buff *x, mpz_t obj)</nametext></name>
       <fsummary>Encode an arbitrary precision integer.</fsummary>
       <desc>
-        <p>Encodes a GMP <c><![CDATA[mpz_t]]></c> integer to binary format.
+        <p>Encodes a GMP <c>mpz_t</c> integer to binary format.
           To use this function, the <c>ei</c> library must be configured and
           compiled to use the GMP library.</p>
       </desc>
@@ -457,7 +457,7 @@ typedef enum {
       <fsummary>Encode a binary.</fsummary>
       <desc>
         <p>Encodes a binary in the binary format. The data is at
-          <c><![CDATA[p]]></c>, of <c><![CDATA[len]]></c> bytes length.</p>
+          <c>p</c>, of <c>len</c> bytes length.</p>
       </desc>
     </func>
 
@@ -466,8 +466,8 @@ typedef enum {
       <name><ret>int</ret><nametext>ei_x_encode_boolean(ei_x_buff* x, int p)</nametext></name>
       <fsummary>Encode a boolean.</fsummary>
       <desc>
-        <p>Encodes a boolean value as the atom <c><![CDATA[true]]></c> if
-          <c>p</c> is not zero, or <c><![CDATA[false]]></c> if <c>p</c> is
+        <p>Encodes a boolean value as the atom <c>true</c> if
+          <c>p</c> is not zero, or <c>false</c> if <c>p</c> is
           zero.</p>
       </desc>
     </func>
@@ -479,9 +479,9 @@ typedef enum {
       <desc>
         <p>Encodes a char (8-bit) as an integer between 0-255 in the binary
           format. For historical reasons the integer argument is of
-          type <c><![CDATA[char]]></c>. Your C code is to consider the specified
-          argument to be of type <c><![CDATA[unsigned char]]></c> even if
-          the C compilers and system may define <c><![CDATA[char]]></c> to be
+          type <c>char</c>. Your C code is to consider the specified
+          argument to be of type <c>unsigned char</c> even if
+          the C compilers and system may define <c>char</c> to be
           signed.</p>
       </desc>
     </func>
@@ -493,7 +493,7 @@ typedef enum {
       <desc>
         <p>Encodes a double-precision (64-bit) floating point number in
           the binary format.</p>
-        <p>Returns <c><![CDATA[-1]]></c> if the floating point
+        <p>Returns <c>-1</c> if the floating point
           number is not finite.</p>
       </desc>
     </func>
@@ -501,7 +501,7 @@ typedef enum {
     <func>
       <name><ret>int</ret><nametext>ei_encode_empty_list(char* buf, int* index)</nametext></name>
       <name><ret>int</ret><nametext>ei_x_encode_empty_list(ei_x_buff* x)</nametext></name>
-      <fsummary>Encode an empty list (<c><![CDATA[nil]]></c>).</fsummary>
+      <fsummary>Encode an empty list (<c>nil</c>).</fsummary>
       <desc>
         <p>Encodes an empty list. It is often used at the tail of a list.</p>
       </desc>
@@ -512,10 +512,10 @@ typedef enum {
       <name><ret>int</ret><nametext>ei_x_encode_fun(ei_x_buff* x, const erlang_fun* fun)</nametext></name>
       <fsummary>Encode a fun.</fsummary>
       <desc>
-        <p>Encodes a fun in the binary format. Parameter <c><![CDATA[p]]></c>
-          points to an <c><![CDATA[erlang_fun]]></c> structure. The
-          <c><![CDATA[erlang_fun]]></c> is not freed automatically, the
-          <c><![CDATA[free_fun]]></c> is to be called if the fun is not needed
+        <p>Encodes a fun in the binary format. Parameter <c>p</c>
+          points to an <c>erlang_fun</c> structure. The
+          <c>erlang_fun</c> is not freed automatically, the
+          <c>free_fun</c> is to be called if the fun is not needed
           after encoding.</p>
       </desc>
     </func>
@@ -526,12 +526,12 @@ typedef enum {
       <fsummary>Encode a list.</fsummary>
       <desc>
         <p>Encodes a list header, with a specified
-          arity. The next <c><![CDATA[arity+1]]></c> terms are the elements
-          (actually its <c><![CDATA[arity]]></c> cons cells) and the tail of the
+          arity. The next <c>arity+1</c> terms are the elements
+          (actually its <c>arity</c> cons cells) and the tail of the
           list. Lists and tuples are encoded recursively, so that a
           list can contain another list or tuple.</p>
         <p>For example, to encode the list
-          <c><![CDATA[[c, d, [e | f]]]]></c>:</p>
+          <c>[c, d, [e | f]]</c>:</p>
         <pre>
 ei_encode_list_header(buf, &amp;i, 3);
 ei_encode_atom(buf, &amp;i, "c");
@@ -543,8 +543,8 @@ ei_encode_empty_list(buf, &amp;i);</pre>
         <note>
           <p>It may seem that there is no way to create a list without
             knowing the number of elements in advance. But indeed
-            there is a way. Notice that the list <c><![CDATA[[a, b, c]]]></c>
-            can be written as <c><![CDATA[[a | [b | [c]]]]]></c>. 
+            there is a way. Notice that the list <c>[a, b, c]</c>
+            can be written as <c>[a | [b | [c]]]</c>.
             Using this, a list can be written as conses.</p>
         </note>
         <p>To encode a list, without knowing the arity in advance:</p>
@@ -573,8 +573,8 @@ ei_x_encode_empty_list(&amp;x);</pre>
       <name><ret>int</ret><nametext>ei_x_encode_longlong(ei_x_buff* x, long long p)</nametext></name>
       <fsummary>Encode integer.</fsummary>
       <desc>
-        <p>Encodes a GCC <c><![CDATA[long long]]></c> or Visual C++
-          <c><![CDATA[__int64]]></c> (64-bit) integer in the binary format.
+        <p>Encodes a GCC <c>long long</c> or Visual C++
+          <c>__int64</c> (64-bit) integer in the binary format.
           This function is missing in the VxWorks port.</p>
       </desc>
     </func>
@@ -606,9 +606,9 @@ ei_x_encode_string(&amp;x, "Banana");</pre>
       <fsummary>Encode a pid.</fsummary>
       <desc>
         <p>Encodes an Erlang process identifier (pid) in the binary
-          format. Parameter <c><![CDATA[p]]></c> points to an
-          <c><![CDATA[erlang_pid]]></c> structure (which should have been
-          obtained earlier with <c><![CDATA[ei_decode_pid()]]></c>).</p>
+          format. Parameter <c>p</c> points to an
+          <c>erlang_pid</c> structure (which should have been
+          obtained earlier with <c>ei_decode_pid()</c>).</p>
       </desc>
     </func>
 
@@ -618,9 +618,9 @@ ei_x_encode_string(&amp;x, "Banana");</pre>
       <fsummary>Encode a port.</fsummary>
       <desc>
         <p>Encodes an Erlang port in the binary format. Parameter
-          <c><![CDATA[p]]></c> points to a <c><![CDATA[erlang_port]]></c>
+          <c>p</c> points to a <c>erlang_port</c>
           structure (which should have been obtained earlier with
-          <c><![CDATA[ei_decode_port()]]></c>).</p>
+          <c>ei_decode_port()</c>).</p>
       </desc>
     </func>
 
@@ -630,9 +630,9 @@ ei_x_encode_string(&amp;x, "Banana");</pre>
       <fsummary>Encode a ref.</fsummary>
       <desc>
         <p>Encodes an Erlang reference in the binary format. Parameter
-          <c><![CDATA[p]]></c> points to a <c><![CDATA[erlang_ref]]></c>
+          <c>p</c> points to a <c>erlang_ref</c>
           structure (which should have been obtained earlier with
-          <c><![CDATA[ei_decode_ref()]]></c>).</p>
+          <c>ei_decode_ref()</c>).</p>
       </desc>
     </func>
 
@@ -646,19 +646,19 @@ ei_x_encode_string(&amp;x, "Banana");</pre>
         <p>Encodes a string in the binary format. (A string in Erlang
           is a list, but is encoded as a character array in the binary
           format.) The string is to be <c>NULL</c>-terminated, except for
-          the <c><![CDATA[ei_x_encode_string_len()]]></c> function.</p>
+          the <c>ei_x_encode_string_len()</c> function.</p>
       </desc>
     </func>
 
     <func>
       <name><ret>int</ret><nametext>ei_encode_term(char *buf, int *index, void *t)</nametext></name>
       <name><ret>int</ret><nametext>ei_x_encode_term(ei_x_buff* x, void *t)</nametext></name>
-      <fsummary>Encode an <c><![CDATA[erl_interface]]></c> term.</fsummary>
+      <fsummary>Encode an <c>erl_interface</c> term.</fsummary>
       <desc>
-        <p>Encodes an <c><![CDATA[ETERM]]></c>, as obtained from
-          <c><![CDATA[erl_interface]]></c>. Parameter <c><![CDATA[t]]></c> is
-          actually an <c><![CDATA[ETERM]]></c> pointer. This function
-          does not free the <c><![CDATA[ETERM]]></c>.</p>
+        <p>Encodes an <c>ETERM</c>, as obtained from
+          <c>erl_interface</c>. Parameter <c>t</c> is
+          actually an <c>ETERM</c> pointer. This function
+          does not free the <c>ETERM</c>.</p>
       </desc>
     </func>
     <func>
@@ -667,9 +667,9 @@ ei_x_encode_string(&amp;x, "Banana");</pre>
       <fsummary>Encode a trace token.</fsummary>
       <desc>
         <p>Encodes an Erlang trace token in the binary format.
-          Parameter <c><![CDATA[p]]></c> points to a
-          <c><![CDATA[erlang_trace]]></c> structure (which should have been
-          obtained earlier with <c><![CDATA[ei_decode_trace()]]></c>).</p>
+          Parameter <c>p</c> points to a
+          <c>erlang_trace</c> structure (which should have been
+          obtained earlier with <c>ei_decode_trace()</c>).</p>
       </desc>
     </func>
 
@@ -679,10 +679,10 @@ ei_x_encode_string(&amp;x, "Banana");</pre>
       <fsummary>Encode a tuple.</fsummary>
       <desc>
         <p>Encodes a tuple header, with a specified
-          arity. The next <c><![CDATA[arity]]></c> terms encoded will be the
+          arity. The next <c>arity</c> terms encoded will be the
           elements of the tuple. Tuples and lists are encoded
           recursively, so that a tuple can contain another tuple or list.</p>
-        <p>For example, to encode the tuple <c><![CDATA[{a, {b, {}}}]]></c>:</p>
+        <p>For example, to encode the tuple <c>{a, {b, {}}}</c>:</p>
         <pre>
 ei_encode_tuple_header(buf, &amp;i, 2);
 ei_encode_atom(buf, &amp;i, "a");
@@ -708,8 +708,8 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
       <name><ret>int</ret><nametext>ei_x_encode_ulonglong(ei_x_buff* x, unsigned long long p)</nametext></name>
       <fsummary>Encode unsigned integer.</fsummary>
       <desc>
-        <p>Encodes a GCC <c><![CDATA[unsigned long long]]></c> or Visual C++
-          <c><![CDATA[unsigned __int64]]></c> (64-bit) integer in the binary
+        <p>Encodes a GCC <c>unsigned long long</c> or Visual C++
+          <c>unsigned __int64</c> (64-bit) integer in the binary
           format. This function is missing in the VxWorks port.</p>
       </desc>
     </func>
@@ -728,13 +728,13 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
       <name><ret>int</ret><nametext>ei_get_type(const char *buf, const int *index, int *type, int *size)</nametext></name>
       <fsummary>Fetch the type and size of an encoded term.</fsummary>
       <desc>
-        <p>Returns the type in <c><![CDATA[type]]></c> and size in
-          <c><![CDATA[size]]></c> of the encoded term. For strings and atoms,
+        <p>Returns the type in <c>type</c> and size in
+          <c>size</c> of the encoded term. For strings and atoms,
           size is the number of characters <em>not</em> including the
-          terminating <c>NULL</c>. For binaries, <c><![CDATA[size]]></c> is the number of
-          bytes. For lists and tuples, <c><![CDATA[size]]></c> is the arity of
-          the object. For other types, <c><![CDATA[size]]></c> is 0. In all
-          cases, <c><![CDATA[index]]></c> is left unchanged.</p>
+          terminating <c>NULL</c>. For binaries, <c>size</c> is the number of
+          bytes. For lists and tuples, <c>size</c> is the arity of
+          the object. For other types, <c>size</c> is 0. In all
+          cases, <c>index</c> is left unchanged.</p>
       </desc>
     </func>
 
@@ -744,21 +744,21 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
       <fsummary>Print a term in clear text.</fsummary>
       <desc>
         <p>Prints a term, in clear text, to the file
-          specified by <c><![CDATA[fp]]></c>, or the buffer pointed to by
-          <c><![CDATA[s]]></c>. It
+          specified by <c>fp</c>, or the buffer pointed to by
+          <c>s</c>. It
           tries to resemble the term printing in the Erlang shell.</p>
-        <p>In <c><![CDATA[ei_s_print_term()]]></c>, parameter
-          <c><![CDATA[s]]></c> is to
+        <p>In <c>ei_s_print_term()</c>, parameter
+          <c>s</c> is to
           point to a dynamically (malloc) allocated string of
-          <c><![CDATA[BUFSIZ]]></c> bytes or a <c>NULL</c> pointer. The string
-          can be reallocated (and <c><![CDATA[*s]]></c> can be updated) by this
-          function if the result is more than <c><![CDATA[BUFSIZ]]></c>
+          <c>BUFSIZ</c> bytes or a <c>NULL</c> pointer. The string
+          can be reallocated (and <c>*s</c> can be updated) by this
+          function if the result is more than <c>BUFSIZ</c>
           characters. The string returned is <c>NULL</c>-terminated.</p>
         <p>The return value is the number of characters written to the file
-          or string, or <c>-1</c> if <c><![CDATA[buf[index]]]></c> does not
+          or string, or <c>-1</c> if <c>buf[index]</c> does not
           contain a valid term.
-          Unfortunately, I/O errors on <c><![CDATA[fp]]></c> is not checked.</p>
-        <p>Argument <c><![CDATA[index]]></c> is updated, that is, this function
+          Unfortunately, I/O errors on <c>fp</c> is not checked.</p>
+        <p>Argument <c>index</c> is updated, that is, this function
           can be viewed as a decode function that decodes a term into a
           human-readable format.</p>
       </desc>
@@ -772,22 +772,22 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
       </type>
       <desc>
         <marker id="ei_set_compat_rel"></marker>
-        <p>By default, the <c><![CDATA[ei]]></c> library is only guaranteed
+        <p>By default, the <c>ei</c> library is only guaranteed
           to be compatible with other Erlang/OTP components from the same
-          release as the <c><![CDATA[ei]]></c> library itself. For example,
-          <c><![CDATA[ei]]></c> from
+          release as the <c>ei</c> library itself. For example,
+          <c>ei</c> from
           Erlang/OTP R10 is not compatible with an Erlang emulator
           from Erlang/OTP R9 by default.</p>
-        <p>A call to <c><![CDATA[ei_set_compat_rel(release_number)]]></c> sets
-          the <c><![CDATA[ei]]></c> library in compatibility mode of release
-          <c><![CDATA[release_number]]></c>. Valid range of
-          <c><![CDATA[release_number]]></c>
+        <p>A call to <c>ei_set_compat_rel(release_number)</c> sets
+          the <c>ei</c> library in compatibility mode of release
+          <c>release_number</c>. Valid range of
+          <c>release_number</c>
           is <c>[7, current release]</c>. This makes it possible to
           communicate with Erlang/OTP components from earlier releases.</p>
         <note>
           <p>If this function is called, it can only be called once
             and must be called before any other functions in the
-            <c><![CDATA[ei]]></c> library are called.</p>
+            <c>ei</c> library are called.</p>
         </note>
         <warning>
           <p>You can run into trouble if this feature is used
@@ -807,16 +807,16 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
           recursively skips elements of lists and tuples, so that a
           full term is skipped. This is a way to get the size of an
           Erlang term.</p>
-        <p><c><![CDATA[buf]]></c> is the buffer.</p>
-        <p><c><![CDATA[index]]></c> is updated to point right after the term
+        <p><c>buf</c> is the buffer.</p>
+        <p><c>index</c> is updated to point right after the term
           in the buffer.</p>
         <note>
           <p>This can be useful when you want to hold arbitrary
             terms: skip them and copy the binary term data to some
             buffer.</p>
         </note>
-        <p>Returns <c><![CDATA[0]]></c> on success, otherwise
-          <c><![CDATA[-1]]></c>.</p>
+        <p>Returns <c>0</c> on success, otherwise
+          <c>-1</c>.</p>
       </desc>
     </func>
 
@@ -825,7 +825,7 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
       <name><ret>int</ret><nametext>ei_x_append_buf(ei_x_buff* x, const char* buf, int len)</nametext></name>
       <fsummary>Append a buffer at the end.</fsummary>
       <desc>
-        <p>Appends data at the end of buffer <c><![CDATA[x]]></c>.</p>
+        <p>Appends data at the end of buffer <c>x</c>.</p>
       </desc>
     </func>
 
@@ -836,8 +836,8 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
       <desc>
         <p>Formats a term, given as a string, to a buffer.
           Works like a sprintf for Erlang terms.
-          <c><![CDATA[fmt]]></c> contains a format string, with arguments like
-          <c><![CDATA[~d]]></c>, to insert terms from variables. The following
+          <c>fmt</c> contains a format string, with arguments like
+          <c>~d</c>, to insert terms from variables. The following
           formats are supported (with the C types given):</p>
         <pre>
 ~a  An atom, char*
@@ -853,7 +853,7 @@ ei_encode_tuple_header(buf, &amp;i, 0);</pre>
         <pre>
 ei_x_format("{~a,~i,~d}", "numbers", 12, 3.14159)
 encodes the tuple {numbers,12,3.14159}</pre>
-        <p><c><![CDATA[ei_x_format_wo_ver()]]></c> formats into a buffer,
+        <p><c>ei_x_format_wo_ver()</c> formats into a buffer,
           without the initial version byte.</p>
       </desc>
     </func>
@@ -862,7 +862,7 @@ encodes the tuple {numbers,12,3.14159}</pre>
       <name><ret>int</ret><nametext>ei_x_free(ei_x_buff* x)</nametext></name>
       <fsummary>Free a buffer.</fsummary>
       <desc>
-        <p>Frees an <c><![CDATA[ei_x_buff]]></c> buffer.
+        <p>Frees an <c>ei_x_buff</c> buffer.
           The memory used by the buffer is returned to the OS.</p>
       </desc>
     </func>
@@ -872,12 +872,12 @@ encodes the tuple {numbers,12,3.14159}</pre>
       <name><ret>int</ret><nametext>ei_x_new_with_version(ei_x_buff* x)</nametext></name>
       <fsummary>Allocate a new buffer.</fsummary>
       <desc>
-        <p>Allocates a new <c><![CDATA[ei_x_buff]]></c> buffer. The
-          fields of the structure pointed to by parameter <c><![CDATA[x]]></c>
+        <p>Allocates a new <c>ei_x_buff</c> buffer. The
+          fields of the structure pointed to by parameter <c>x</c>
           is filled in, and a default buffer is allocated.
-          <c><![CDATA[ei_x_new_with_version()]]></c> also puts an initial
+          <c>ei_x_new_with_version()</c> also puts an initial
           version byte, which is used in the binary format (so that
-          <c><![CDATA[ei_x_encode_version()]]></c> will not be needed.)</p>
+          <c>ei_x_encode_version()</c> will not be needed.)</p>
       </desc>
     </func>
   </funcs>
@@ -889,7 +889,7 @@ encodes the tuple {numbers,12,3.14159}</pre>
 
     <list type="bulleted">
       <item>Be careful with the version header, use
-        <c><![CDATA[ei_x_new_with_version()]]></c> when appropriate.</item>
+        <c>ei_x_new_with_version()</c> when appropriate.</item>
       <item>Turn on distribution tracing on the Erlang node.</item>
       <item>Check the result codes from <c>ei_decode_-calls</c>.</item>
     </list>
diff --git a/lib/erl_interface/doc/src/ei_connect.xml b/lib/erl_interface/doc/src/ei_connect.xml
index be34fb7c53..607a7cbff4 100644
--- a/lib/erl_interface/doc/src/ei_connect.xml
+++ b/lib/erl_interface/doc/src/ei_connect.xml
@@ -44,32 +44,32 @@
       <seealso marker="erts:erlang#nodes/0"><c>erlang:nodes/0</c></seealso>
       in <c>ERTS</c>.</p>
 
-    <p>The environment variable <c><![CDATA[ERL_EPMD_PORT]]></c> can be used
+    <p>The environment variable <c>ERL_EPMD_PORT</c> can be used
       to indicate which logical cluster a C-node belongs to.</p>
   </description>
 
   <section>
     <title>Time-Out Functions</title>
     <p>Most functions appear in a version with the suffix
-      <c><![CDATA[_tmo]]></c> appended to the function name. Those functions
+      <c>_tmo</c> appended to the function name. Those functions
       take an extra argument, a time-out in <em>milliseconds</em>. The
       semantics is this: for each communication primitive involved in
       the operation, if the primitive does not complete within the time
       specified, the function returns an error and
-      <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[ETIMEDOUT]]></c>.
+      <c>erl_errno</c> is set to <c>ETIMEDOUT</c>.
       With communication primitive is meant an operation on the socket, like
-      <c><![CDATA[connect]]></c>, <c><![CDATA[accept]]></c>,
-      <c><![CDATA[recv]]></c>, or <c><![CDATA[send]]></c>.</p>
+      <c>connect</c>, <c>accept</c>,
+      <c>recv</c>, or <c>send</c>.</p>
 
     <p>Clearly the time-outs are for implementing fault tolerance,
-      not to keep hard real-time promises. The <c><![CDATA[_tmo]]></c> functions
+      not to keep hard real-time promises. The <c>_tmo</c> functions
       are for detecting non-responsive peers and to avoid blocking on
       socket operations.</p>
 
-    <p>A time-out value of <c><![CDATA[0]]></c> (zero) means that time-outs are
-      disabled. Calling a <c><![CDATA[_tmo]]></c> function with the last
-      argument as <c><![CDATA[0]]></c> is therefore the same thing as calling
-      the function without the <c><![CDATA[_tmo]]></c> suffix.</p>
+    <p>A time-out value of <c>0</c> (zero) means that time-outs are
+      disabled. Calling a <c>_tmo</c> function with the last
+      argument as <c>0</c> is therefore the same thing as calling
+      the function without the <c>_tmo</c> suffix.</p>
 
     <p>As with all other functions starting with <c>ei_</c>,
       you are <em>not</em> expected
@@ -80,9 +80,9 @@
       avoid problems, leave the socket options alone. <c>ei</c> handles
       any socket options that need modification.</p>
 
-    <p>In all other senses, the <c><![CDATA[_tmo]]></c> functions inherit all
+    <p>In all other senses, the <c>_tmo</c> functions inherit all
       the return values and the semantics from the functions without
-      the <c><![CDATA[_tmo]]></c> suffix.</p>
+      the <c>_tmo</c> suffix.</p>
   </section>
 
   <funcs>
@@ -105,15 +105,15 @@
           connection from a client process.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[ec]]></c> is the C-node structure.</p>
+            <p><c>ec</c> is the C-node structure.</p>
           </item>
           <item>
-            <p><c><![CDATA[listensock]]></c> is an open socket descriptor on
-              which <c><![CDATA[listen()]]></c> has previously been called.</p>
+            <p><c>listensock</c> is an open socket descriptor on
+              which <c>listen()</c> has previously been called.</p>
           </item>
           <item>
-            <p><c><![CDATA[conp]]></c> is a pointer to an
-              <c><![CDATA[ErlConnect]]></c> struct, described as follows:</p>
+            <p><c>conp</c> is a pointer to an
+              <c>ErlConnect</c> struct, described as follows:</p>
             <code type="none"><![CDATA[
 typedef struct {
   char ipadr[4];             
@@ -122,10 +122,10 @@ typedef struct {
         ]]></code>
           </item>
         </list>
-        <p>On success, <c><![CDATA[conp]]></c> is filled in with the address and
+        <p>On success, <c>conp</c> is filled in with the address and
           node name of the connecting client and a file descriptor is
-          returned. On failure, <c><![CDATA[ERL_ERROR]]></c> is returned and
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EIO]]></c>.</p>
+          returned. On failure, <c>ERL_ERROR</c> is returned and
+          <c>erl_errno</c> is set to <c>EIO</c>.</p>
       </desc>
     </func>
 
@@ -146,34 +146,34 @@ typedef struct {
       <fsummary>Establish a connection to an Erlang node.</fsummary>
       <desc>
         <p>Sets up a connection to an Erlang node.</p>
-        <p><c><![CDATA[ei_xconnect()]]></c> requires the IP address of the
+        <p><c>ei_xconnect()</c> requires the IP address of the
           remote host and the alive name of the remote node to be
-          specified. <c><![CDATA[ei_connect()]]></c> provides an alternative
+          specified. <c>ei_connect()</c> provides an alternative
           interface and determines the information from the node name
           provided.</p>
         <list type="bulleted">
-          <item><c><![CDATA[addr]]></c> is the 32-bit IP address of the remote
+          <item><c>addr</c> is the 32-bit IP address of the remote
             host.</item>
-          <item><c><![CDATA[alive]]></c> is the alivename of the remote node.
+          <item><c>alive</c> is the alivename of the remote node.
           </item>
-          <item><c><![CDATA[node]]></c> is the name of the remote node.</item>
+          <item><c>node</c> is the name of the remote node.</item>
         </list>
         <p>These functions return an open file descriptor on success, or
           a negative value indicating that an error occurred. In the latter
-          case they set <c><![CDATA[erl_errno]]></c> to one of the
+          case they set <c>erl_errno</c> to one of the
           following:</p>
         <taglist>
-          <tag><c><![CDATA[EHOSTUNREACH]]></c></tag>
-          <item>The remote host <c><![CDATA[node]]></c> is unreachable.</item>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>EHOSTUNREACH</c></tag>
+          <item>The remote host <c>node</c> is unreachable.</item>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
-        <p>Also, <c><![CDATA[errno]]></c> values from
-          <c><![CDATA[socket]]></c><em>(2)</em> and
-          <c><![CDATA[connect]]></c><em>(2)</em>
-          system calls may be propagated into <c><![CDATA[erl_errno]]></c>.</p>
+        <p>Also, <c>errno</c> values from
+          <c>socket</c><em>(2)</em> and
+          <c>connect</c><em>(2)</em>
+          system calls may be propagated into <c>erl_errno</c>.</p>
         <p><em>Example:</em></p>
         <code type="none"><![CDATA[
 #define NODE   "[email protected]"
@@ -196,49 +196,49 @@ fd = ei_xconnect(&ec, &addr, ALIVE);
       <name><ret>int</ret><nametext>ei_connect_xinit(ei_cnode* ec, const char *thishostname, const char *thisalivename, const char *thisnodename, Erl_IpAddr thisipaddr, const char *cookie, short creation)</nametext></name>
       <fsummary>Initialize for a connection.</fsummary>
       <desc>
-        <p>Initializes the <c><![CDATA[ec]]></c> structure, to
+        <p>Initializes the <c>ec</c> structure, to
           identify the node name and cookie of the server. One of them
           must be called before other functions that works on the
-          <c><![CDATA[ei_cnode]]></c> type or a file descriptor associated with
+          <c>ei_cnode</c> type or a file descriptor associated with
           a connection to another node is used.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[ec]]></c> is a structure containing information about
-              the C-node. It is used in other <c><![CDATA[ei]]></c> functions
+            <p><c>ec</c> is a structure containing information about
+              the C-node. It is used in other <c>ei</c> functions
               for connecting and receiving data.</p>
           </item>
           <item>
-            <p><c><![CDATA[this_node_name]]></c> is the registered name of the
+            <p><c>this_node_name</c> is the registered name of the
               process (the name before '@').</p>
           </item>
           <item>
-            <p><c><![CDATA[cookie]]></c> is the cookie for the node.</p>
+            <p><c>cookie</c> is the cookie for the node.</p>
           </item>
           <item>
-            <p><c><![CDATA[creation]]></c> identifies a specific instance of a
+            <p><c>creation</c> identifies a specific instance of a
               C-node. It can help prevent the node from receiving messages
               sent to an earlier process with the same registered name.</p>
           </item>
           <item>
-            <p><c><![CDATA[thishostname]]></c> is the name of the machine we are
+            <p><c>thishostname</c> is the name of the machine we are
               running on. If long names are to be used, they are to be fully
-              qualified (that is, <c><![CDATA[durin.erix.ericsson.se]]></c>
-              instead of <c><![CDATA[durin]]></c>).</p>
+              qualified (that is, <c>durin.erix.ericsson.se</c>
+              instead of <c>durin</c>).</p>
           </item>
           <item>
-            <p><c><![CDATA[thisalivename]]></c> is the registered name of the
+            <p><c>thisalivename</c> is the registered name of the
               process.</p>
           </item>
           <item>
-            <p><c><![CDATA[thisnodename]]></c> is the full name of the node,
-              that is, <c><![CDATA[einode@durin]]></c>.</p>
+            <p><c>thisnodename</c> is the full name of the node,
+              that is, <c>einode@durin</c>.</p>
           </item>
           <item>
-            <p><c><![CDATA[thispaddr]]></c> if the IP address of the host.</p>
+            <p><c>thispaddr</c> if the IP address of the host.</p>
           </item>
         </list>
         <p>A C-node acting as a server is assigned a creation
-          number when it calls <c><![CDATA[ei_publish()]]></c>.</p>
+          number when it calls <c>ei_publish()</c>.</p>
         <p>A connection is closed by simply closing the socket.
           For information about how to close the socket gracefully (when
           there are outgoing packets before close), see the relevant system
@@ -306,32 +306,32 @@ if (ei_connect_init(&ec, "madonna", "cookie...", n++) < 0) {
           with the local name server EPMD, thereby allowing
           other processes to send messages by using the registered name.
           Before calling either of these functions, the process should
-          have called <c><![CDATA[bind()]]></c> and <c><![CDATA[listen()]]></c>
+          have called <c>bind()</c> and <c>listen()</c>
           on an open socket.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[ec]]></c> is the C-node structure.</p>
+            <p><c>ec</c> is the C-node structure.</p>
           </item>
           <item>
-            <p><c><![CDATA[port]]></c> is the local name to register, and is to
+            <p><c>port</c> is the local name to register, and is to
               be the same as the port number that was previously bound to the
               socket.</p>
           </item>
           <item>
-            <p><c><![CDATA[addr]]></c> is the 32-bit IP address of the local
+            <p><c>addr</c> is the 32-bit IP address of the local
               host.</p>
           </item>
         </list>
         <p>To unregister with EPMD, simply close the returned descriptor. Do
-          not use <c><![CDATA[ei_unpublish()]]></c>, which is deprecated
+          not use <c>ei_unpublish()</c>, which is deprecated
           anyway.</p>
         <p>On success, the function returns a descriptor connecting the
           calling process to EPMD. On failure, <c>-1</c> is returned and
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EIO]]></c>.</p>
-        <p>Also, <c><![CDATA[errno]]></c> values from
-          <c><![CDATA[socket]]></c><em>(2)</em> and
-          <c><![CDATA[connect]]></c><em>(2)</em> system calls may be propagated
-          into <c><![CDATA[erl_errno]]></c>.</p>
+          <c>erl_errno</c> is set to <c>EIO</c>.</p>
+        <p>Also, <c>errno</c> values from
+          <c>socket</c><em>(2)</em> and
+          <c>connect</c><em>(2)</em> system calls may be propagated
+          into <c>erl_errno</c>.</p>
       </desc>
     </func>
 
@@ -353,34 +353,34 @@ if (ei_connect_init(&ec, "madonna", "cookie...", n++) < 0) {
           of bytes in the Erlang external format.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+            <p><c>fd</c> is an open descriptor to an Erlang
               connection. It is obtained from a previous
-              <c><![CDATA[ei_connect]]></c> or <c><![CDATA[ei_accept]]></c>.</p>
+              <c>ei_connect</c> or <c>ei_accept</c>.</p>
           </item>
           <item>
-            <p><c><![CDATA[bufp]]></c> is a buffer large enough to hold the
+            <p><c>bufp</c> is a buffer large enough to hold the
               expected message.</p>
           </item>
           <item>
-            <p><c><![CDATA[bufsize]]></c> indicates the size of
-              <c><![CDATA[bufp]]></c>.</p>
+            <p><c>bufsize</c> indicates the size of
+              <c>bufp</c>.</p>
           </item>
         </list>
         <p>If a <em>tick</em> occurs, that is, the Erlang node on the
           other end of the connection has polled this node to see if it
-          is still alive, the function returns <c><![CDATA[ERL_TICK]]></c> and
+          is still alive, the function returns <c>ERL_TICK</c> and
           no message is placed in the buffer. Also,
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EAGAIN]]></c>.</p>
+          <c>erl_errno</c> is set to <c>EAGAIN</c>.</p>
         <p>On success, the message is placed in the specified buffer
           and the function returns the number of bytes actually read. On
-          failure, the function returns <c><![CDATA[ERL_ERROR]]></c> and sets
-          <c><![CDATA[erl_errno]]></c> to one of the following:</p>
+          failure, the function returns <c>ERL_ERROR</c> and sets
+          <c>erl_errno</c> to one of the following:</p>
         <taglist>
-          <tag><c><![CDATA[EAGAIN]]></c></tag>
+          <tag><c>EAGAIN</c></tag>
           <item>Temporary error: Try again.</item>
-          <tag><c><![CDATA[EMSGSIZE]]></c></tag>
+          <tag><c>EMSGSIZE</c></tag>
           <item>Buffer is too small.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
       </desc>
@@ -394,20 +394,20 @@ if (ei_connect_init(&ec, "madonna", "cookie...", n++) < 0) {
           generated by the interface compiler and with code following
           examples in the same application.</p>
         <p>In essence, the function performs the same operation as
-          <c><![CDATA[ei_xreceive_msg]]></c>, but instead of using an
+          <c>ei_xreceive_msg</c>, but instead of using an
           <c>ei_x_buff</c>, the function expects a pointer to a character
-          pointer (<c><![CDATA[mbufp]]></c>), where the character pointer
-          is to point to a memory area allocated by <c><![CDATA[malloc]]></c>.
-          Argument <c><![CDATA[bufsz]]></c> is to be a pointer to an integer
+          pointer (<c>mbufp</c>), where the character pointer
+          is to point to a memory area allocated by <c>malloc</c>.
+          Argument <c>bufsz</c> is to be a pointer to an integer
           containing the exact size (in bytes) of the memory area. The function
           may reallocate the memory area and will in such cases put the new
-          size in <c><![CDATA[*bufsz]]></c> and update
-          <c><![CDATA[*mbufp]]></c>.</p>
+          size in <c>*bufsz</c> and update
+          <c>*mbufp</c>.</p>
         <p>Returns either <c>ERL_TICK</c> or the
-          <c><![CDATA[msgtype]]></c> field of the
-          <c><![CDATA[erlang_msg *msg]]></c>. The length
-          of the message is put in <c><![CDATA[*msglen]]></c>. On error
-          a value <c><![CDATA[< 0]]></c> is returned.</p>
+          <c>msgtype</c> field of the
+          <c>erlang_msg *msg</c>. The length
+          of the message is put in <c>*msglen</c>. On error
+          a value <c>&lt; 0</c> is returned.</p>
         <p>It is recommended to use <c>ei_xreceive_msg</c> instead when
           possible, for the sake of readability. However, the function will
           be retained in the interface for compatibility and
@@ -432,23 +432,23 @@ if (ei_connect_init(&ec, "madonna", "cookie...", n++) < 0) {
       <name><ret>int</ret><nametext>ei_xreceive_msg(int fd, erlang_msg* msg, ei_x_buff* x)</nametext></name>
       <fsummary>Receive a message.</fsummary>
       <desc>
-        <p>Receives a message to the buffer in <c><![CDATA[x]]></c>.
-          <c><![CDATA[ei_xreceive_msg]]></c> allows the buffer in
-          <c><![CDATA[x]]></c> to grow, but <c><![CDATA[ei_receive_msg]]></c>
+        <p>Receives a message to the buffer in <c>x</c>.
+          <c>ei_xreceive_msg</c> allows the buffer in
+          <c>x</c> to grow, but <c>ei_receive_msg</c>
           fails if the message is larger than the pre-allocated buffer in
-          <c><![CDATA[x]]></c>.</p>
+          <c>x</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[msg]]></c> is a pointer to an
-            <c><![CDATA[erlang_msg]]></c> structure
+          <item><c>msg</c> is a pointer to an
+            <c>erlang_msg</c> structure
             and contains information on the message received.</item>
-          <item><c><![CDATA[x]]></c> is buffer obtained from
-            <c><![CDATA[ei_x_new]]></c>.</item>
+          <item><c>x</c> is buffer obtained from
+            <c>ei_x_new</c>.</item>
         </list>
-        <p>On success, the functions return <c><![CDATA[ERL_MSG]]></c> and the
-          <c><![CDATA[msg]]></c> struct is initialized.
-          <c><![CDATA[erlang_msg]]></c> is defined as follows:</p>
+        <p>On success, the functions return <c>ERL_MSG</c> and the
+          <c>msg</c> struct is initialized.
+          <c>erlang_msg</c> is defined as follows:</p>
         <code type="none"><![CDATA[
 typedef struct {
     long msgtype;
@@ -459,31 +459,31 @@ typedef struct {
     erlang_trace token;
 } erlang_msg;
         ]]></code>
-        <p><c><![CDATA[msgtype]]></c> identifies the type of message, and is
+        <p><c>msgtype</c> identifies the type of message, and is
           one of the following:</p>
         <taglist>
-          <tag><c><![CDATA[ERL_SEND]]></c></tag>
+          <tag><c>ERL_SEND</c></tag>
           <item>
             <p>Indicates that an ordinary send operation has occurred.
-              <c><![CDATA[msg->to]]></c> contains the pid of the recipient (the
+              <c>msg-&gt;to</c> contains the pid of the recipient (the
               C-node).</p>
           </item>
-          <tag><c><![CDATA[ERL_REG_SEND]]></c></tag>
+          <tag><c>ERL_REG_SEND</c></tag>
           <item>
             <p>A registered send operation occurred.
-              <c><![CDATA[msg->from]]></c> contains the pid of the sender.</p>
+              <c>msg-&gt;from</c> contains the pid of the sender.</p>
           </item>
-          <tag><c><![CDATA[ERL_LINK]]></c> or
-            <c><![CDATA[ERL_UNLINK]]></c></tag>
+          <tag><c>ERL_LINK</c> or
+            <c>ERL_UNLINK</c></tag>
           <item>
-            <p><c><![CDATA[msg->to]]></c> and
-              <c><![CDATA[msg->from]]></c> contain the pids of the
+            <p><c>msg-&gt;to</c> and
+              <c>msg-&gt;from</c> contain the pids of the
               sender and recipient of the link or unlink.</p>
           </item>
-          <tag><c><![CDATA[ERL_EXIT]]></c></tag>
+          <tag><c>ERL_EXIT</c></tag>
           <item>
-            <p>Indicates a broken link. <c><![CDATA[msg->to]]></c> and
-              <c><![CDATA[msg->from]]></c> contain the pids of the linked
+            <p>Indicates a broken link. <c>msg-&gt;to</c> and
+              <c>msg-&gt;from</c> contain the pids of the linked
                processes.</p>
           </item>
         </taglist>
@@ -520,19 +520,19 @@ typedef struct {
         <p>Sends an Erlang term to a registered process.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+            <p><c>fd</c> is an open descriptor to an Erlang
               connection.</p>
           </item>
-          <item><c><![CDATA[server_name]]></c> is the registered name of the
+          <item><c>server_name</c> is the registered name of the
             intended recipient.</item>
-          <item><c><![CDATA[buf]]></c> is the buffer containing the term in
+          <item><c>buf</c> is the buffer containing the term in
             binary format.</item>
-          <item><c><![CDATA[len]]></c> is the length of the message in bytes.
+          <item><c>len</c> is the length of the message in bytes.
           </item>
         </list>
         <p>Returns <c>0</c> if successful, otherwise <c>-1</c>. In
-          the latter case it sets <c><![CDATA[erl_errno]]></c> to
-          <c><![CDATA[EIO]]></c>.</p>
+          the latter case it sets <c>erl_errno</c> to
+          <c>EIO</c>.</p>
         <p><em>Example:</em></p>
         <p>Send the atom "ok" to the process "worker":</p>
         <code type="none"><![CDATA[
@@ -563,75 +563,75 @@ if (ei_reg_send(&ec, fd, x.buff, x.index) < 0)
       <fsummary>Remote Procedure Call from C to Erlang.</fsummary>
       <desc>
         <p>Supports calling Erlang functions on remote nodes.
-          <c><![CDATA[ei_rpc_to()]]></c> sends an RPC request to a remote node
-          and <c><![CDATA[ei_rpc_from()]]></c> receives the results of such a
-          call. <c><![CDATA[ei_rpc()]]></c> combines the functionality of these
+          <c>ei_rpc_to()</c> sends an RPC request to a remote node
+          and <c>ei_rpc_from()</c> receives the results of such a
+          call. <c>ei_rpc()</c> combines the functionality of these
           two functions by sending an RPC request and waiting for the results.
           See also <seealso marker="kernel:rpc#call/4">
           <c>rpc:call/4</c></seealso> in Kernel.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[ec]]></c> is the C-node structure previously
-              initiated by a call to <c><![CDATA[ei_connect_init()]]></c> or
-              <c><![CDATA[ei_connect_xinit()]]></c>.</p>
+            <p><c>ec</c> is the C-node structure previously
+              initiated by a call to <c>ei_connect_init()</c> or
+              <c>ei_connect_xinit()</c>.</p>
           </item>
           <item>
-            <p><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+            <p><c>fd</c> is an open descriptor to an Erlang
               connection.</p>
           </item>
           <item>
-            <p><c><![CDATA[timeout]]></c> is the maximum time (in milliseconds)
-              to wait for results. Specify <c><![CDATA[ERL_NO_TIMEOUT]]></c> to
+            <p><c>timeout</c> is the maximum time (in milliseconds)
+              to wait for results. Specify <c>ERL_NO_TIMEOUT</c> to
               wait forever.
-              <c><![CDATA[ei_rpc()]]></c> waits infinitely for the answer,
+              <c>ei_rpc()</c> waits infinitely for the answer,
               that is, the call will never time out.</p>
           </item>
           <item>
-            <p><c><![CDATA[mod]]></c> is the name of the module containing the
+            <p><c>mod</c> is the name of the module containing the
               function to be run on the remote node.</p>
           </item>
           <item>
-            <p><c><![CDATA[fun]]></c> is the name of the function to run.</p>
+            <p><c>fun</c> is the name of the function to run.</p>
           </item>
           <item>
-            <p><c><![CDATA[argbuf]]></c> is a pointer to a buffer with an
+            <p><c>argbuf</c> is a pointer to a buffer with an
               encoded Erlang list, without a version magic number, containing
               the arguments to be passed to the function.</p>
           </item>
           <item>
-            <p><c><![CDATA[argbuflen]]></c> is the length of the buffer
+            <p><c>argbuflen</c> is the length of the buffer
               containing the encoded Erlang list.</p>
           </item>
           <item>
-            <p><c><![CDATA[msg]]></c> is structure of type
-              <c><![CDATA[erlang_msg]]></c> and contains information on the
+            <p><c>msg</c> is structure of type
+              <c>erlang_msg</c> and contains information on the
               message
-              received. For a description of the <c><![CDATA[erlang_msg]]></c>
+              received. For a description of the <c>erlang_msg</c>
               format, see <seealso marker="#ei_receive_msg">
               <c>ei_receive_msg</c></seealso>.</p>
           </item>
           <item>
-            <p><c><![CDATA[x]]></c> points to the dynamic buffer that receives
-              the result. For <c><![CDATA[ei_rpc()]]></c> this is the result
+            <p><c>x</c> points to the dynamic buffer that receives
+              the result. For <c>ei_rpc()</c> this is the result
               without the version magic number. For
-              <c><![CDATA[ei_rpc_from()]]></c> the result returns a version
-              magic number and a 2-tuple <c><![CDATA[{rex,Reply}]]></c>.</p>
+              <c>ei_rpc_from()</c> the result returns a version
+              magic number and a 2-tuple <c>{rex,Reply}</c>.</p>
           </item>
         </list>
-        <p><c><![CDATA[ei_rpc()]]></c> returns the number of bytes in the
+        <p><c>ei_rpc()</c> returns the number of bytes in the
           result on success and <c>-1</c> on failure.
-          <c><![CDATA[ei_rpc_from()]]></c> returns the
-          number of bytes, otherwise one of <c><![CDATA[ERL_TICK]]></c>,
-          <c><![CDATA[ERL_TIMEOUT]]></c>,
-          and <c><![CDATA[ERL_ERROR]]></c>. When failing, all three
-          functions set <c><![CDATA[erl_errno]]></c> to one of the
+          <c>ei_rpc_from()</c> returns the
+          number of bytes, otherwise one of <c>ERL_TICK</c>,
+          <c>ERL_TIMEOUT</c>,
+          and <c>ERL_ERROR</c>. When failing, all three
+          functions set <c>erl_errno</c> to one of the
           following:</p>
         <taglist>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
-          <tag><c><![CDATA[ETIMEDOUT]]></c></tag>
+          <tag><c>ETIMEDOUT</c></tag>
           <item>Time-out expired.</item>
-          <tag><c><![CDATA[EAGAIN]]></c></tag>
+          <tag><c>EAGAIN</c></tag>
           <item>Temporary error: Try again.</item>
         </taglist>
         <p><em>Example:</em></p>
@@ -662,11 +662,11 @@ if (ei_decode_version(result.buff, &index) < 0
       <fsummary>Retrieve the pid of the C-node.</fsummary>
       <desc>
         <p>Retrieves the pid of the C-node. Every C-node
-          has a (pseudo) pid used in <c><![CDATA[ei_send_reg]]></c>,
-          <c><![CDATA[ei_rpc]]></c>,
-          and others. This is contained in a field in the <c><![CDATA[ec]]></c>
+          has a (pseudo) pid used in <c>ei_send_reg</c>,
+          <c>ei_rpc</c>,
+          and others. This is contained in a field in the <c>ec</c>
           structure. It will be safe for a long time to fetch this
-          field directly from the <c><![CDATA[ei_cnode]]></c> structure.</p>
+          field directly from the <c>ei_cnode</c> structure.</p>
       </desc>
     </func>
 
@@ -676,18 +676,18 @@ if (ei_decode_version(result.buff, &index) < 0
       <desc>
         <p>Sends an Erlang term to a process.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[to]]></c> is the pid of the intended recipient of
+          <item><c>to</c> is the pid of the intended recipient of
             the message.</item>
-          <item><c><![CDATA[buf]]></c> is the buffer containing the term in
+          <item><c>buf</c> is the buffer containing the term in
             binary format.</item>
-          <item><c><![CDATA[len]]></c> is the length of the message in bytes.
+          <item><c>len</c> is the length of the message in bytes.
           </item>
         </list>
         <p>Returns <c>0</c> if successful, otherwise <c>-1</c>. In
-          the latter case it sets <c><![CDATA[erl_errno]]></c> to
-          <c><![CDATA[EIO]]></c>.</p>
+          the latter case it sets <c>erl_errno</c> to
+          <c>EIO</c>.</p>
       </desc>
     </func>
 
@@ -720,14 +720,14 @@ if (ei_decode_version(result.buff, &index) < 0
         <p>This function is retained for compatibility with code
           generated by the interface compiler and with code following
           examples in the same application.</p>
-        <p>The function works as <c><![CDATA[ei_reg_send]]></c> with one
-          exception. Instead of taking <c><![CDATA[ei_cnode]]></c> as first
+        <p>The function works as <c>ei_reg_send</c> with one
+          exception. Instead of taking <c>ei_cnode</c> as first
           argument, it takes a second argument, an
-          <c><![CDATA[erlang_pid]]></c>,
+          <c>erlang_pid</c>,
           which is to be the process identifier of the sending process
           (in the Erlang distribution protocol).</p>
-        <p>A suitable <c><![CDATA[erlang_pid]]></c> can be constructed from the
-          <c><![CDATA[ei_cnode]]></c> structure by the following example
+        <p>A suitable <c>erlang_pid</c> can be constructed from the
+          <c>ei_cnode</c> structure by the following example
           code:</p>
         <code type="none"><![CDATA[
 ei_cnode ec;
@@ -769,10 +769,10 @@ self->num = fd;
       <desc>
         <p>Can be used to retrieve information about
           the C-node. These values are initially set with
-          <c><![CDATA[ei_connect_init()]]></c> or
-          <c><![CDATA[ei_connect_xinit()]]></c>.</p>
+          <c>ei_connect_init()</c> or
+          <c>ei_connect_xinit()</c>.</p>
         <p>These function simply fetch the appropriate field from the
-          <c><![CDATA[ec]]></c>
+          <c>ec</c>
           structure. Read the field directly will probably be safe for
           a long time, so these functions are not really needed.</p>
       </desc>
@@ -788,16 +788,16 @@ self->num = fd;
           <c>-relaxed_command_check</c>, which it normally is not.</p>
         <p>To unregister a node you have published, you should
 	  close the descriptor that was returned by
-	  <c><![CDATA[ei_publish()]]></c>.</p>
+	  <c>ei_publish()</c>.</p>
         <warning>
           <p>This function is deprecated and will be removed in a future
 	  release.</p>
         </warning>
-        <p><c><![CDATA[ec]]></c> is the node structure of the node to
+        <p><c>ec</c> is the node structure of the node to
           unregister.</p>
         <p>If the node was successfully unregistered from EPMD, the
           function returns <c>0</c>. Otherwise, <c>-1</c> is returned and
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EIO]]></c>.</p>
+          <c>erl_errno</c> is set to <c>EIO</c>.</p>
       </desc>
     </func>
 
@@ -818,18 +818,18 @@ self->num = fd;
     <p>If a connection attempt fails, the following can be checked:</p>
 
     <list type="bulleted">
-      <item><c><![CDATA[erl_errno]]></c>.</item>
+      <item><c>erl_errno</c>.</item>
       <item>That the correct cookie was used</item>
       <item>That EPMD is running</item>
       <item>That the remote Erlang node on the other side is running the
-        same version of Erlang as the <c><![CDATA[ei]]></c> library</item>
-      <item>That environment variable <c><![CDATA[ERL_EPMD_PORT]]></c>
+        same version of Erlang as the <c>ei</c> library</item>
+      <item>That environment variable <c>ERL_EPMD_PORT</c>
         is set correctly</item>
     </list>
 
     <p>The connection attempt can be traced by setting a trace level by either
-      using <c><![CDATA[ei_set_tracelevel]]></c> or by setting environment
-      variable <c><![CDATA[EI_TRACELEVEL]]></c>.
+      using <c>ei_set_tracelevel</c> or by setting environment
+      variable <c>EI_TRACELEVEL</c>.
       The trace levels have the following messages:</p>
 
     <list>
diff --git a/lib/erl_interface/doc/src/ei_users_guide.xml b/lib/erl_interface/doc/src/ei_users_guide.xml
index 2c82f9ae7f..0eed50b50b 100644
--- a/lib/erl_interface/doc/src/ei_users_guide.xml
+++ b/lib/erl_interface/doc/src/ei_users_guide.xml
@@ -102,21 +102,21 @@ Eshell V4.7.4  (abort with ^G)
 /usr/local/otp    ]]></code>
 
     <p>To compile your code, ensure that your C compiler knows where
-      to find <c><![CDATA[erl_interface.h]]></c> by specifying an appropriate
-      <c><![CDATA[-I]]></c> argument on the command line, or add it to
-      the <c><![CDATA[CFLAGS]]></c> definition in your
-      <c><![CDATA[Makefile]]></c>. The correct value for this path is
-      <c><![CDATA[$OTPROOT/lib/erl_interface-$EIVSN/include]]></c>,
+      to find <c>erl_interface.h</c> by specifying an appropriate
+      <c>-I</c> argument on the command line, or add it to
+      the <c>CFLAGS</c> definition in your
+      <c>Makefile</c>. The correct value for this path is
+      <c>$OTPROOT/lib/erl_interface-$EIVSN/include</c>,
       where:</p>
 
     <list type="bulleted">
       <item>
-        <p><c><![CDATA[$OTPROOT]]></c> is the path reported by
-          <c><![CDATA[code:root_dir/0]]></c> in the example above.</p>
+        <p><c>$OTPROOT</c> is the path reported by
+          <c>code:root_dir/0</c> in the example above.</p>
       </item>
       <item>
-        <p><c><![CDATA[$EIVSN]]></c> is the version of the <c>Erl_Interface</c> application,
-          for example, <c><![CDATA[erl_interface-3.2.3]]></c>.</p>
+        <p><c>$EIVSN</c> is the version of the <c>Erl_Interface</c> application,
+          for example, <c>erl_interface-3.2.3</c>.</p>
       </item>
     </list>
 
@@ -128,16 +128,16 @@ $ cc -c -I/usr/local/otp/lib/erl_interface-3.2.3/include myprog.c    ]]></code>
     <p>When linking:</p>
 
     <list type="bulleted">
-      <item>Specify the path to <c><![CDATA[liberl_interface.a]]></c> and
-        <c><![CDATA[libei.a]]></c> with
-        <c><![CDATA[-L$OTPROOT/lib/erl_interface-3.2.3/lib]]></c>.</item>
+      <item>Specify the path to <c>liberl_interface.a</c> and
+        <c>libei.a</c> with
+        <c>-L$OTPROOT/lib/erl_interface-3.2.3/lib</c>.</item>
       <item>Specify the name of the libraries with
-        <c><![CDATA[-lerl_interface -lei]]></c>.</item>
+        <c>-lerl_interface -lei</c>.</item>
     </list>
 
     <p>Do this on the command line or add the flags to the
-      <c><![CDATA[LDFLAGS]]></c> definition in your
-      <c><![CDATA[Makefile]]></c>.</p>
+      <c>LDFLAGS</c> definition in your
+      <c>Makefile</c>.</p>
 
     <p>Linking the code:</p>
 
@@ -146,9 +146,9 @@ $ ld -L/usr/local/otp/lib/erl_interface-3.2.3/
                             lib myprog.o -lerl_interface -lei -o myprog    ]]></code>
 
     <p>On some systems it can be necessary to link with some more
-      libraries (for example, <c><![CDATA[libnsl.a]]></c> and
-      <c><![CDATA[libsocket.a]]></c> on Solaris, or
-      <c><![CDATA[wsock32.lib]]></c> on Windows) to use the
+      libraries (for example, <c>libnsl.a</c> and
+      <c>libsocket.a</c> on Solaris, or
+      <c>wsock32.lib</c> on Windows) to use the
       communication facilities of <c>Erl_Interface</c>.</p>
 
     <p>If you use the <c>Erl_Interface</c> functions in a threaded
@@ -156,18 +156,18 @@ $ ld -L/usr/local/otp/lib/erl_interface-3.2.3/
       <c>Erl_Interface</c> needs access to some of the synchronization
       facilities in your threads package. You must specify extra
       compiler flags to indicate which of the packages you use. Define
-      <c><![CDATA[_REENTRANT]]></c> and either <c><![CDATA[STHREADS]]></c> or
-      <c><![CDATA[PTHREADS]]></c>. The default is to use POSIX threads if
-      <c><![CDATA[_REENTRANT]]></c> is specified.</p>
+      <c>_REENTRANT</c> and either <c>STHREADS</c> or
+      <c>PTHREADS</c>. The default is to use POSIX threads if
+      <c>_REENTRANT</c> is specified.</p>
   </section>
 
   <section>
     <title>Initializing the Erl_Interface Library</title>
     <p>Before calling any of the other <c>Erl_Interface</c> functions, call
-      <c><![CDATA[erl_init()]]></c> exactly once to initialize the library.
-      <c><![CDATA[erl_init()]]></c> takes two arguments. However, the arguments
+      <c>erl_init()</c> exactly once to initialize the library.
+      <c>erl_init()</c> takes two arguments. However, the arguments
       are no longer used by <c>Erl_Interface</c> and are therefore to be
-      specified as <c><![CDATA[erl_init(NULL,0)]]></c>.</p>
+      specified as <c>erl_init(NULL,0)</c>.</p>
   </section>
 
   <section>
@@ -181,7 +181,7 @@ $ ld -L/usr/local/otp/lib/erl_interface-3.2.3/
       several C functions that create and manipulate Erlang data
       structures. The library also contains an encode and a decode function.
       The following example shows how to create and encode an Erlang tuple
-      <c><![CDATA[{tobbe,3928}]]></c>:</p>
+      <c>{tobbe,3928}</c>:</p>
 
     <code type="none"><![CDATA[
 ETERM *arr[2], *tuple;
@@ -193,8 +193,8 @@ arr[1] = erl_mk_integer(3928);
 tuple  = erl_mk_tuple(arr, 2);
 i = erl_encode(tuple, buf);    ]]></code>
 
-    <p>Alternatively, you can use <c><![CDATA[erl_send()]]></c> and
-      <c><![CDATA[erl_receive_msg]]></c>, which handle the encoding and
+    <p>Alternatively, you can use <c>erl_send()</c> and
+      <c>erl_receive_msg</c>, which handle the encoding and
       decoding of messages transparently.</p>
 
     <p>For a complete description, see the following modules:</p>
@@ -232,8 +232,8 @@ erl_free_compound(ep);      ]]></code>
 
     <p>As in the previous examples, it is your responsibility to free the
       memory allocated for Erlang terms. In this example,
-      <c><![CDATA[erl_free_compound()]]></c> ensures that the complete term
-      pointed to by <c><![CDATA[ep]]></c> is released. This is necessary
+      <c>erl_free_compound()</c> ensures that the complete term
+      pointed to by <c>ep</c> is released. This is necessary
       because the pointer from the second call to <c>erl_format</c> is lost.</p>
 
     <p>The following example shows a slightly different solution:</p>
@@ -247,7 +247,7 @@ erl_free_term(ep);
 erl_free_term(ep2);      ]]></code>
 
     <p>In this case, you free the two terms independently. The order in
-      which you free the terms <c><![CDATA[ep]]></c> and <c><![CDATA[ep2]]></c>
+      which you free the terms <c>ep</c> and <c>ep2</c>
       is not important,
       because the <c>Erl_Interface</c> library uses reference counting to
       determine when it is safe to remove objects.</p>
@@ -274,7 +274,7 @@ erl_eterm_release();
   <section>
     <title>Pattern Matching</title>
     <p>An Erlang pattern is a term that can contain unbound variables or
-      <c><![CDATA["do not care"]]></c> symbols. Such a pattern can be matched
+      <c>"do not care"</c> symbols. Such a pattern can be matched
       against a
       term and, if the match is successful, any unbound variables in the
       pattern will be bound as a side effect. The content of a bound
@@ -348,7 +348,7 @@ erl_connect_init(identification_number, cookie, creation);    ]]></code>
 
     <p>After initialization, you set up the connection to the Erlang node.
       To specify the Erlang node you want to connect to, use
-      <c><![CDATA[erl_connect()]]></c>. The following example sets up the
+      <c>erl_connect()</c>. The following example sets up the
       connection and is to result in a valid socket file descriptor:</p>
 
     <code type="none"><![CDATA[
@@ -357,7 +357,7 @@ char *nodename="[email protected]"; /* An example */
 if ((sockfd = erl_connect(nodename)) < 0)
   erl_err_quit("ERROR: erl_connect failed");    ]]></code>
 
-    <p><c><![CDATA[erl_err_quit()]]></c> prints the specified string and
+    <p><c>erl_err_quit()</c> prints the specified string and
       terminates the program. For more information, see the
       <seealso marker="erl_error"><c>erl_error</c></seealso> module.</p>
   </section>
@@ -366,24 +366,24 @@ if ((sockfd = erl_connect(nodename)) < 0)
     <title>Using EPMD</title>
     <p><seealso marker="erts:epmd"><c>erts:epmd</c></seealso>
       is the Erlang Port Mapper Daemon. Distributed
-      Erlang nodes register with <c><![CDATA[epmd]]></c> on the local host to
+      Erlang nodes register with <c>epmd</c> on the local host to
       indicate to other nodes that they exist and can accept connections.
-      <c><![CDATA[epmd]]></c> maintains a register of
+      <c>epmd</c> maintains a register of
       node and port number information, and when a node wishes to connect to
-      another node, it first contacts <c><![CDATA[epmd]]></c> to find the
+      another node, it first contacts <c>epmd</c> to find the
       correct port number to connect to.</p>
 
     <p>When you use
       <seealso marker="erl_connect"><c>erl_connect</c></seealso>
       to connect to an Erlang node, a connection is first made to
-      <c><![CDATA[epmd]]></c> and, if the node is known, a
+      <c>epmd</c> and, if the node is known, a
       connection is then made to the Erlang node.</p>
 
-    <p>C nodes can also register themselves with <c><![CDATA[epmd]]></c>
+    <p>C nodes can also register themselves with <c>epmd</c>
       if they want other
       nodes in the system to be able to find and connect to them.</p>
 
-    <p>Before registering with <c><![CDATA[epmd]]></c>, you must first
+    <p>Before registering with <c>epmd</c>, you must first
       create a listen socket and bind it to a port. Then:</p>
 
     <code type="none"><![CDATA[
@@ -391,17 +391,17 @@ int pub;
 
 pub = erl_publish(port);    ]]></code>
 
-    <p><c><![CDATA[pub]]></c> is a file descriptor now connected to
-      <c><![CDATA[epmd]]></c>. <c><![CDATA[epmd]]></c>
+    <p><c>pub</c> is a file descriptor now connected to
+      <c>epmd</c>. <c>epmd</c>
       monitors the other end of the connection. If it detects that the
       connection has been closed, the node becomes unregistered. So, if you
       explicitly close the descriptor or if your node fails, it becomes
-      unregistered from <c><![CDATA[epmd]]></c>.</p>
+      unregistered from <c>epmd</c>.</p>
 
     <p>Notice that on some systems (such as VxWorks), a failed node is
       not detected by this mechanism, as the operating system does not
       automatically close descriptors that were left open when the node
-      failed. If a node has failed in this way, <c><![CDATA[epmd]]></c>
+      failed. If a node has failed in this way, <c>epmd</c>
       prevents you from
       registering a new node with the old name, as it thinks that the old
       name is still in use. In this case, you must unregister the name
@@ -410,7 +410,7 @@ pub = erl_publish(port);    ]]></code>
     <code type="none"><![CDATA[
 erl_unpublish(node);    ]]></code>
 
-    <p>This causes <c><![CDATA[epmd]]></c> to close the connection from the
+    <p>This causes <c>epmd</c> to close the connection from the
       far end. Notice
       that if the name was in fact still in use by a node, the results of
       this operation are unpredictable. Also, doing this does not cause the
@@ -442,15 +442,15 @@ erl_unpublish(node);    ]]></code>
         <c>erl_connect:erl_receive_msg</c></seealso></item>
     </list>
 
-    <p><c><![CDATA[erl_receive()]]></c> receives the message into a buffer,
-      while <c><![CDATA[erl_receive_msg()]]></c> decodes the message into an
+    <p><c>erl_receive()</c> receives the message into a buffer,
+      while <c>erl_receive_msg()</c> decodes the message into an
       Erlang term.</p>
 
     <section>
       <title>Example of Sending Messages</title>
-      <p>In the following example, <c><![CDATA[{Pid, hello_world}]]></c> is
-        sent to a registered process <c><![CDATA[my_server]]></c>. The message
-        is encoded by <c><![CDATA[erl_send()]]></c>:</p>
+      <p>In the following example, <c>{Pid, hello_world}</c> is
+        sent to a registered process <c>my_server</c>. The message
+        is encoded by <c>erl_send()</c>:</p>
 
       <code type="none"><![CDATA[
 extern const char *erl_thisnodename(void);
@@ -467,16 +467,16 @@ erl_reg_send(sockfd, "my_server", emsg);
 erl_free_term(emsg);      ]]></code>
 
       <p>The first element of the tuple that is sent is your own
-        pid. This enables <c><![CDATA[my_server]]></c> to reply.
+        pid. This enables <c>my_server</c> to reply.
         For more information about the primitives, see the
         <seealso marker="erl_connect"><c>erl_connect</c></seealso> module.</p>
     </section>
 
     <section>
       <title>Example of Receiving Messages</title>
-      <p>In this example, <c><![CDATA[{Pid, Something}]]></c> is received. The
+      <p>In this example, <c>{Pid, Something}</c> is received. The
         received pid is then used to return
-        <c><![CDATA[{goodbye,Pid}]]></c>.</p>
+        <c>{goodbye,Pid}</c>.</p>
 
       <code type="none"><![CDATA[
 ETERM *arr[2], *answer;
@@ -498,15 +498,15 @@ if ((rc = erl_receive_msg(sockfd , buf, BUFSIZE, &emsg)) == ERL_MSG) {
         occasionally polls all its connected neighbors in an attempt to
         detect failed nodes or communication links. A node that receives such
         a message is expected to respond immediately with an
-        <c><![CDATA[ERL_TICK]]></c> message. This is done automatically by
-        <c><![CDATA[erl_receive()]]></c>. However, when this has occurred,
-        <c><![CDATA[erl_receive]]></c> returns <c><![CDATA[ERL_TICK]]></c> to
+        <c>ERL_TICK</c> message. This is done automatically by
+        <c>erl_receive()</c>. However, when this has occurred,
+        <c>erl_receive</c> returns <c>ERL_TICK</c> to
         the caller without storing a message into the
-        <c><![CDATA[ErlMessage]]></c> structure.</p>
+        <c>ErlMessage</c> structure.</p>
 
       <p>When a message has been received, it is the caller's responsibility
-        to free the received message <c><![CDATA[emsg.msg]]></c> and
-        <c><![CDATA[emsg.to]]></c> or <c><![CDATA[emsg.from]]></c>,
+        to free the received message <c>emsg.msg</c> and
+        <c>emsg.to</c> or <c>emsg.from</c>,
         depending on the type of message received.</p>
 
       <p>For more information, see the
@@ -538,14 +538,14 @@ if (!erl_match(ep, reply))
 erl_free_term(ep);
 erl_free_term(reply);    ]]></code>
 
-    <p><c><![CDATA[c:c/1]]></c> is called to compile the specified module on
-      the remote node. <c><![CDATA[erl_match()]]></c> checks that the
+    <p><c>c:c/1</c> is called to compile the specified module on
+      the remote node. <c>erl_match()</c> checks that the
       compilation was
-      successful by testing for the expected <c><![CDATA[ok]]></c>.</p>
+      successful by testing for the expected <c>ok</c>.</p>
 
-    <p>For more information about <c><![CDATA[erl_rpc()]]></c> and its
-      companions <c><![CDATA[erl_rpc_to()]]></c> and
-      <c><![CDATA[erl_rpc_from()]]></c>, see the
+    <p>For more information about <c>erl_rpc()</c> and its
+      companions <c>erl_rpc_to()</c> and
+      <c>erl_rpc_from()</c>, see the
       <seealso marker="erl_connect"><c>erl_connect</c></seealso> module.</p>
   </section>
 
@@ -582,15 +582,15 @@ free(names);    ]]></code>
       <c>erl_global:erl_global_names</c></seealso>
       allocates and returns a buffer containing
       all the names known to the <c>global</c> module in <c>Kernel</c>.
-      <c><![CDATA[count]]></c> is initialized to
+      <c>count</c> is initialized to
       indicate the number of names in the array. The array of strings in names
       is terminated by a <c>NULL</c> pointer, so it is not necessary to use
-      <c><![CDATA[count]]></c> to determine when the last name is reached.</p>
+      <c>count</c> to determine when the last name is reached.</p>
 
     <p>It is the caller's responsibility to free the array.
       <c>erl_global_names</c> allocates the array and all the strings
-      using a single call to <c><![CDATA[malloc()]]></c>, so
-      <c><![CDATA[free(names)]]></c> is all that is necessary.</p>
+      using a single call to <c>malloc()</c>, so
+      <c>free(names)</c> is all that is necessary.</p>
 
     <p>To look up one of the names:</p>
 
@@ -600,16 +600,16 @@ char node[256];
 
 pid = erl_global_whereis(fd,"schedule",node);    ]]></code>
 
-    <p>If <c><![CDATA["schedule"]]></c> is known to the
+    <p>If <c>"schedule"</c> is known to the
       <c>global</c> module in <c>Kernel</c>, an Erlang pid is
       returned that can be used to send messages to the schedule service.
-      Also, <c><![CDATA[node]]></c> is initialized to contain the name of
+      Also, <c>node</c> is initialized to contain the name of
       the node where the service is registered, so that you can make a
       connection to it by simply passing the variable to
       <seealso marker="erl_connect"><c>erl_connect</c></seealso>.</p>
 
     <p>Before registering a name, you should already have registered your
-      port number with <c><![CDATA[epmd]]></c>. This is not strictly necessary,
+      port number with <c>epmd</c>. This is not strictly necessary,
       but if you
       neglect to do so, then other nodes wishing to communicate with your
       service cannot find or connect to your process.</p>
@@ -629,7 +629,7 @@ erl_global_register(fd,servicename,pid);    ]]></code>
         to wait for incoming connections.</p>
 
     <note>
-      <p>Remember to free <c><![CDATA[pid]]></c> later with
+      <p>Remember to free <c>pid</c> later with
         <seealso marker="erl_malloc#erl_free_term">
         <c>erl_malloc:erl_free_term</c></seealso>.</p>
     </note>
@@ -743,7 +743,7 @@ ei_reg_close(reg);    ]]></code>
 ei_reg_dump(fd, reg, "mtab", dumpflags);      ]]></code>
 
       <p>This example back up the contents of the registry to the
-        specified <c>Mnesia</c> table <c><![CDATA["mtab"]]></c>.
+        specified <c>Mnesia</c> table <c>"mtab"</c>.
         Once a registry has been backed
         up to <c>Mnesia</c> like this, more backups only affect
         objects that have been modified since the most recent backup, that is,
@@ -756,7 +756,7 @@ ei_reg_dump(fd, reg, "mtab", dumpflags);      ]]></code>
       <code type="none"><![CDATA[
 ei_reg_restore(fd, reg, "mtab");      ]]></code>
 
-      <p>This reads the entire contents of <c><![CDATA["mtab"]]></c> into the
+      <p>This reads the entire contents of <c>"mtab"</c> into the
         specified registry. After the restore, all the objects in the registry
         are marked as unmodified, so a later backup only affects
         objects that you have modified since the restore.</p>
@@ -775,8 +775,8 @@ ei_reg_restore(fd, reg, "mtab");      ]]></code>
         important that some simple guidelines are followed.</p>
 
       <p>Most importantly, the object must have been created with a single call
-        to <c><![CDATA[malloc()]]></c> (or similar), so that it can later be
-        removed by a single call to <c><![CDATA[free()]]></c>.
+        to <c>malloc()</c> (or similar), so that it can later be
+        removed by a single call to <c>free()</c>.
         Objects are freed by the registry
         when it is closed, or when you assign a new value to an object that
         previously contained a string or binary.</p>
diff --git a/lib/erl_interface/doc/src/erl_call.xml b/lib/erl_interface/doc/src/erl_call.xml
index 706dd271cc..f1e52b1889 100644
--- a/lib/erl_interface/doc/src/erl_call.xml
+++ b/lib/erl_interface/doc/src/erl_call.xml
@@ -35,9 +35,9 @@
   <com>erl_call</com>
   <comsummary>Call/start a distributed Erlang node.</comsummary>
   <description>
-    <p><c><![CDATA[erl_call]]></c> makes it possible to start and/or
+    <p><c>erl_call</c> makes it possible to start and/or
       communicate with a distributed Erlang node. It is built upon the
-      <c><![CDATA[Erl_Interface]]></c> library as an example application.
+      <c>Erl_Interface</c> library as an example application.
       Its purpose is to use a Unix shell script to interact with a distributed
       Erlang node. It performs all communication with the Erlang
       <em>rex server</em>, using the standard Erlang RPC facility. It does not
@@ -45,14 +45,14 @@
 
     <p>The main use is to either start a distributed Erlang node
       or to make an ordinary function call. However, it is also
-      possible to pipe an Erlang module to <c><![CDATA[erl_call]]></c> and have
+      possible to pipe an Erlang module to <c>erl_call</c> and have
       it compiled, or to pipe a sequence of Erlang expressions to be evaluated
       (similar to the Erlang shell).</p>
 
-    <p>Options, which cause <c><![CDATA[stdin]]></c> to be read, can be used
+    <p>Options, which cause <c>stdin</c> to be read, can be used
       with advantage,
       as scripts from within (Unix) shell scripts. Another nice use
-      of <c><![CDATA[erl_call]]></c> could be from (HTTP) CGI-bin scripts.</p>
+      of <c>erl_call</c> could be from (HTTP) CGI-bin scripts.</p>
   </description>
 
   <funcs>
@@ -67,65 +67,65 @@
           <tag><c>-a [Mod [Fun [Args]]]]</c></tag>
           <item>
             <p>(<em>Optional.</em>) Applies the specified function
-              and returns the result. <c><![CDATA[Mod]]></c> must be specified.
+              and returns the result. <c>Mod</c> must be specified.
               However, <c>start</c> and <c>[]</c> are assumed for unspecified
-              <c><![CDATA[Fun]]></c> and <c><![CDATA[Args]]></c>, respectively.
-              <c><![CDATA[Args]]></c> is to be in the same format as for
+              <c>Fun</c> and <c>Args</c>, respectively.
+              <c>Args</c> is to be in the same format as for
               <seealso marker="erts:erlang#apply/3">
               <c>erlang:apply/3</c></seealso> in <c>ERTS</c>.</p>
             <p>Notice that this flag takes exactly one argument, so quoting
-              can be necessary to group <c><![CDATA[Mod]]></c>,
-              <c><![CDATA[Fun]]></c>, and <c><![CDATA[Args]]></c> in a manner
+              can be necessary to group <c>Mod</c>,
+              <c>Fun</c>, and <c>Args</c> in a manner
               dependent on the behavior of your command shell.</p>
           </item>
           <tag><c>-c Cookie</c></tag>
           <item>
             <p>(<em>Optional.</em>) Use this option to specify a certain cookie.
-              If no cookie is specified, the <c><![CDATA[~/.erlang.cookie]]></c>
+              If no cookie is specified, the <c>~/.erlang.cookie</c>
               file is read and its content is used as cookie. The Erlang node
               we want to communicate with must have the same cookie.</p>
           </item>
           <tag><c>-d</c></tag>
           <item>
             <p>(<em>Optional.</em>) Debug mode. This causes all I/O to be output
-              to the <c><![CDATA[~/.erl_call.out.Nodename]]></c> file, where
-              <c><![CDATA[Nodename]]></c>
+              to the <c>~/.erl_call.out.Nodename</c> file, where
+              <c>Nodename</c>
               is the node name of the Erlang node in question.</p>
           </item>
           <tag><c>-e</c></tag>
           <item>
             <p>(<em>Optional.</em>) Reads a sequence of Erlang expressions,
               separated by comma (,) and ended with a full stop (.), from
-              <c><![CDATA[stdin]]></c> until EOF (Control-D). Evaluates the
+              <c>stdin</c> until EOF (Control-D). Evaluates the
               expressions and returns the result from the last expression.
-              Returns <c><![CDATA[{ok,Result}]]></c> on success.</p>
+              Returns <c>{ok,Result}</c> on success.</p>
           </item>
           <tag><c>-h HiddenName</c></tag>
           <item>
             <p>(<em>Optional.</em>) Specifies the name of the hidden node
-              that <c><![CDATA[erl_call]]></c> represents.</p>
+              that <c>erl_call</c> represents.</p>
           </item>
           <tag><c>-m</c></tag>
           <item>
             <p>(<em>Optional.</em>) Reads an Erlang module from
-              <c><![CDATA[stdin]]></c> and compiles it.</p>
+              <c>stdin</c> and compiles it.</p>
           </item>
           <tag><c>-n Node</c></tag>
           <item>
-            <p>(One of <c><![CDATA[-n, -name, -sname]]></c> is required.)
-              Has the same meaning as <c><![CDATA[-name]]></c> and can still be
+            <p>(One of <c>-n, -name, -sname</c> is required.)
+              Has the same meaning as <c>-name</c> and can still be
               used for backward compatibility reasons.</p>
           </item>
           <tag><c>-name Node</c></tag>
           <item>
-            <p>(One of <c><![CDATA[-n, -name, -sname]]></c> is required.)
-              <c><![CDATA[Node]]></c> is the name of the node to be
+            <p>(One of <c>-n, -name, -sname</c> is required.)
+              <c>Node</c> is the name of the node to be
               started or communicated with. It is assumed that
-              <c><![CDATA[Node]]></c> is started with
-              <c><![CDATA[erl -name]]></c>, which means that fully
+              <c>Node</c> is started with
+              <c>erl -name</c>, which means that fully
               qualified long node names are used. If option
-              <c><![CDATA[-s]]></c> is specified, an Erlang node will (if
-              necessary) be started with <c><![CDATA[erl -name]]></c>.</p>
+              <c>-s</c> is specified, an Erlang node will (if
+              necessary) be started with <c>erl -name</c>.</p>
           </item>
           <tag><c>-q</c></tag>
           <item>
@@ -135,13 +135,13 @@
           <tag><c>-r</c></tag>
           <item>
             <p>(<em>Optional.</em>) Generates a random name of the hidden node
-              that <c><![CDATA[erl_call]]></c> represents.</p>
+              that <c>erl_call</c> represents.</p>
           </item>
           <tag><c>-s</c></tag>
           <item>
             <p>(<em>Optional.</em>) Starts a distributed Erlang node if
               necessary. This means that in a sequence of calls, where
-              '<c><![CDATA[-s]]></c>' and '<c><![CDATA[-n Node]]></c>' are
+              '<c>-s</c>' and '<c>-n Node</c>' are
               constant, only the first call starts the Erlang node. This makes
               the rest of the communication very fast. This flag is currently
               only available on Unix-like platforms (Linux, Mac OS X, Solaris,
@@ -149,25 +149,25 @@
           </item>
           <tag><c>-sname Node</c></tag>
           <item>
-            <p>(One of <c><![CDATA[-n, -name, -sname]]></c> is required.)
-              <c><![CDATA[Node]]></c> is the name of the node to be started
-              or communicated with. It is assumed that <c><![CDATA[Node]]></c>
-              is started with <c><![CDATA[erl -sname]]></c>, which means that
-              short node names are used. If option <c><![CDATA[-s]]></c> is
+            <p>(One of <c>-n, -name, -sname</c> is required.)
+              <c>Node</c> is the name of the node to be started
+              or communicated with. It is assumed that <c>Node</c>
+              is started with <c>erl -sname</c>, which means that
+              short node names are used. If option <c>-s</c> is
               specified, an Erlang node is started (if necessary) with
-              <c><![CDATA[erl -sname]]></c>.</p>
+              <c>erl -sname</c>.</p>
           </item>
           <tag><c>-v</c></tag>
           <item>
-            <p>(<em>Optional.</em>) Prints a lot of <c><![CDATA[verbose]]></c>
+            <p>(<em>Optional.</em>) Prints a lot of <c>verbose</c>
               information. This is only useful for the developer and maintainer
-              of <c><![CDATA[erl_call]]></c>.</p>
+              of <c>erl_call</c>.</p>
           </item>
           <tag><c>-x ErlScript</c></tag>
           <item>
             <p>(<em>Optional.</em>) Specifies another name of the Erlang
               startup script to be used. If not specified, the standard
-              <c><![CDATA[erl]]></c> startup script is used.</p>
+              <c>erl</c> startup script is used.</p>
           </item>
         </taglist>
       </desc>
@@ -176,7 +176,7 @@
 
   <section>
     <title>Examples</title>
-    <p>To start an Erlang node and call <c><![CDATA[erlang:time/0]]></c>:</p>
+    <p>To start an Erlang node and call <c>erlang:time/0</c>:</p>
 
     <code type="none"><![CDATA[
 erl_call -s -a 'erlang time' -n madonna
@@ -184,7 +184,7 @@ erl_call -s -a 'erlang time' -n madonna
     ]]></code>
 
     <p>To terminate an Erlang node by calling
-      <c><![CDATA[erlang:halt/0]]></c>:</p>
+      <c>erlang:halt/0</c>:</p>
 
     <code type="none"><![CDATA[
 erl_call -s -a 'erlang halt' -n madonna
diff --git a/lib/erl_interface/doc/src/erl_connect.xml b/lib/erl_interface/doc/src/erl_connect.xml
index a6b9e586f4..76ef6588c2 100644
--- a/lib/erl_interface/doc/src/erl_connect.xml
+++ b/lib/erl_interface/doc/src/erl_connect.xml
@@ -59,10 +59,10 @@
         <p>This function is used by a server process to accept a
           connection from a client process.</p>
         <list type="bulleted">
-          <item><c><![CDATA[listensock]]></c> is an open socket descriptor on
-            which <c><![CDATA[listen()]]></c> has previously been called.</item>
-          <item><c><![CDATA[conp]]></c> is a pointer to an
-            <c><![CDATA[ErlConnect]]></c> struct, described as follows:</item>
+          <item><c>listensock</c> is an open socket descriptor on
+            which <c>listen()</c> has previously been called.</item>
+          <item><c>conp</c> is a pointer to an
+            <c>ErlConnect</c> struct, described as follows:</item>
         </list>
         <code type="none"><![CDATA[
 typedef struct {
@@ -70,10 +70,10 @@ typedef struct {
   char nodename[MAXNODELEN];
 } ErlConnect;
         ]]></code>
-        <p>On success, <c><![CDATA[conp]]></c> is filled in with the address and
+        <p>On success, <c>conp</c> is filled in with the address and
           node name of the connecting client and a file descriptor is
-          returned. On failure, <c><![CDATA[ERL_ERROR]]></c> is returned and
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EIO]]></c>.</p>
+          returned. On failure, <c>ERL_ERROR</c> is returned and
+          <c>erl_errno</c> is set to <c>EIO</c>.</p>
       </desc>
     </func>
 
@@ -85,9 +85,9 @@ typedef struct {
       </type>
       <desc>
         <p>Closes an open connection to an Erlang node.</p>
-        <p><c><![CDATA[Fd]]></c> is a file descriptor obtained from
-          <c><![CDATA[erl_connect()]]></c> or
-          <c><![CDATA[erl_xconnect()]]></c>.</p>
+        <p><c>Fd</c> is a file descriptor obtained from
+          <c>erl_connect()</c> or
+          <c>erl_xconnect()</c>.</p>
         <p>Returns <c>0</c> on success. If the call fails, a non-zero value
           is returned, and the reason for the error can be obtained with the
           appropriate platform-dependent call.</p>
@@ -104,33 +104,33 @@ typedef struct {
       </type>
       <desc>
         <p>Sets up a connection to an Erlang node.</p>
-        <p><c><![CDATA[erl_xconnect()]]></c> requires the IP address of the
+        <p><c>erl_xconnect()</c> requires the IP address of the
           remote host and the alivename of the remote node to be
-          specified. <c><![CDATA[erl_connect()]]></c> provides an alternative
+          specified. <c>erl_connect()</c> provides an alternative
           interface, and determines the information from the node name
           provided.</p>
         <list type="bulleted">
-          <item><c><![CDATA[addr]]></c> is the 32-bit IP address of the remote
+          <item><c>addr</c> is the 32-bit IP address of the remote
             host.</item>
-          <item><c><![CDATA[alive]]></c> is the alivename of the remote node.
+          <item><c>alive</c> is the alivename of the remote node.
           </item>
-          <item><c><![CDATA[node]]></c> is the name of the remote node.</item>
+          <item><c>node</c> is the name of the remote node.</item>
         </list>
         <p>Returns an open file descriptor on success, otherwise a negative
-          value. In the latter case <c><![CDATA[erl_errno]]></c> is set to one
+          value. In the latter case <c>erl_errno</c> is set to one
           of:</p>
         <taglist>
-          <tag><c><![CDATA[EHOSTUNREACH]]></c></tag>
-          <item>The remote host <c><![CDATA[node]]></c> is unreachable.</item>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>EHOSTUNREACH</c></tag>
+          <item>The remote host <c>node</c> is unreachable.</item>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
-        <p>Also, <c><![CDATA[errno]]></c> values from
-          <c><![CDATA[socket]]></c><em>(2)</em> and
-          <c><![CDATA[connect]]></c><em>(2)</em>
-          system calls can be propagated into <c><![CDATA[erl_errno]]></c>.</p>
+        <p>Also, <c>errno</c> values from
+          <c>socket</c><em>(2)</em> and
+          <c>connect</c><em>(2)</em>
+          system calls can be propagated into <c>erl_errno</c>.</p>
         <p><em>Example:</em></p>
         <code type="none"><![CDATA[
 #define NODE   "[email protected]"
@@ -160,69 +160,69 @@ erl_xconnect( &addr , ALIVE );
         <v>struct in_addr *addr;</v>
       </type>
       <desc>
-        <p>Initializes the <c><![CDATA[erl_connect]]></c> module.
+        <p>Initializes the <c>erl_connect</c> module.
           In particular, these functions are used to identify the name of the
           C-node from which they are called. One of these functions must
           be called before any of the other functions in the <c>erl_connect</c>
           module are used.</p>
-        <p><c><![CDATA[erl_connect_xinit()]]></c> stores for later use
+        <p><c>erl_connect_xinit()</c> stores for later use
           information about:</p>
         <list type="bulleted">
-          <item>Hostname of the node, <c><![CDATA[host]]></c></item>
-          <item>Alivename, <c><![CDATA[alive]]></c></item>
-          <item>Node name, <c><![CDATA[node]]></c></item>
-          <item>IP address, <c><![CDATA[addr]]></c></item>
-          <item>Cookie, <c><![CDATA[cookie]]></c></item>
-          <item>Creation number, <c><![CDATA[creation]]></c></item>
+          <item>Hostname of the node, <c>host</c></item>
+          <item>Alivename, <c>alive</c></item>
+          <item>Node name, <c>node</c></item>
+          <item>IP address, <c>addr</c></item>
+          <item>Cookie, <c>cookie</c></item>
+          <item>Creation number, <c>creation</c></item>
         </list>
-        <p><c><![CDATA[erl_connect_init()]]></c>
+        <p><c>erl_connect_init()</c>
           provides an alternative interface that does not require as much
           information from the caller. Instead,
-          <c><![CDATA[erl_connect_init()]]></c>
-          uses <c><![CDATA[gethostbyname()]]></c> to obtain default values.</p>
-        <p>If you use <c><![CDATA[erl_connect_init()]]></c>, your node will
+          <c>erl_connect_init()</c>
+          uses <c>gethostbyname()</c> to obtain default values.</p>
+        <p>If you use <c>erl_connect_init()</c>, your node will
           have a short name, that is, it will not be fully qualified. If you
           need to use fully qualified (long) names, use
-          <c><![CDATA[erl_connect_xinit()]]></c> instead.</p>
+          <c>erl_connect_xinit()</c> instead.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[host]]></c> is the name of the host on which the node
+            <p><c>host</c> is the name of the host on which the node
               is running.</p>
           </item>
           <item>
-            <p><c><![CDATA[alive]]></c> is the alivename of the node.</p>
+            <p><c>alive</c> is the alivename of the node.</p>
           </item>
           <item>
-            <p><c><![CDATA[node]]></c> is the node name. It is to
+            <p><c>node</c> is the node name. It is to
                 be of the form <em>alivename@hostname</em>.</p>
           </item>
           <item>
-            <p><c><![CDATA[addr]]></c> is the 32-bit IP address of
-              <c><![CDATA[host]]></c>.</p>
+            <p><c>addr</c> is the 32-bit IP address of
+              <c>host</c>.</p>
           </item>
           <item>
-            <p><c><![CDATA[cookie]]></c> is the authorization string required
+            <p><c>cookie</c> is the authorization string required
               for access to the remote node. If <c>NULL</c>, the user
               <c>HOME</c> directory is searched for a cookie file
-              <c><![CDATA[.erlang.cookie]]></c>. The path to
+              <c>.erlang.cookie</c>. The path to
               the home directory is retrieved from environment variable
-              <c><![CDATA[HOME]]></c> on Unix and from the
-              <c><![CDATA[HOMEDRIVE]]></c> and
-              <c><![CDATA[HOMEPATH]]></c> variables on Windows. For more
+              <c>HOME</c> on Unix and from the
+              <c>HOMEDRIVE</c> and
+              <c>HOMEPATH</c> variables on Windows. For more
               details, see the <seealso marker="kernel:auth">
               <c>auth</c></seealso> module in Kernel.</p>
           </item>
           <item>
-            <p><c><![CDATA[creation]]></c> helps identifying a particular
+            <p><c>creation</c> helps identifying a particular
               instance of a C-node. In particular, it can help prevent us from
               receiving messages sent to an earlier process with the same
               registered name.</p>
           </item>
         </list>
         <p>A C-node acting as a server is assigned a creation number
-          when it calls <c><![CDATA[erl_publish()]]></c>.</p>
-        <p><c><![CDATA[number]]></c> is used by
-          <c><![CDATA[erl_connect_init()]]></c> to
+          when it calls <c>erl_publish()</c>.</p>
+        <p><c>number</c> is used by
+          <c>erl_connect_init()</c> to
           construct the actual node name. In Example 2
           below, <em>"[email protected]"</em> is the resulting node name.</p>
         <p><em>Example 1:</em></p>
@@ -256,23 +256,23 @@ if (!erl_connect_init(17, "samplecookiestring...", 0))
           with the local name server EPMD, thereby allowing
           other processes to send messages by using the registered name.
           Before calling this function, the process should
-          have called <c><![CDATA[bind()]]></c> and <c><![CDATA[listen()]]></c>
+          have called <c>bind()</c> and <c>listen()</c>
           on an open socket.</p>
-        <p><c><![CDATA[port]]></c> is the local name to register, and is to be
+        <p><c>port</c> is the local name to register, and is to be
           the same as the port number that was previously bound to the
           socket.</p>
         <p>To unregister with EPMD, simply close the returned descriptor.</p>
         <p>On success, a descriptor connecting the calling process to EPMD is
           returned. On failure, <c>-1</c> is returned and
-          <c><![CDATA[erl_errno]]></c> is set to:</p>
+          <c>erl_errno</c> is set to:</p>
         <taglist>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
-        <p>Also, <c><![CDATA[errno]]></c> values from
-          <c><![CDATA[socket]]></c><em>(2)</em>
-          and <c><![CDATA[connect]]></c><em>(2)</em> system calls can be
-          propagated into <c><![CDATA[erl_errno]]></c>.</p>
+        <p>Also, <c>errno</c> values from
+          <c>socket</c><em>(2)</em>
+          and <c>connect</c><em>(2)</em> system calls can be
+          propagated into <c>erl_errno</c>.</p>
       </desc>
     </func>
 
@@ -288,28 +288,28 @@ if (!erl_connect_init(17, "samplecookiestring...", 0))
         <p>Receives a message consisting of a sequence
           of bytes in the Erlang external format.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[bufp]]></c> is a buffer large enough to hold the
+          <item><c>bufp</c> is a buffer large enough to hold the
             expected message.</item>
-          <item><c><![CDATA[bufsize]]></c> indicates the size of
-            <c><![CDATA[bufp]]></c>.</item>
+          <item><c>bufsize</c> indicates the size of
+            <c>bufp</c>.</item>
         </list>
         <p>If a <em>tick</em> occurs, that is, the Erlang node on the
           other end of the connection has polled this node to see if it
-          is still alive, the function returns <c><![CDATA[ERL_TICK]]></c> and
+          is still alive, the function returns <c>ERL_TICK</c> and
           no message is placed in the buffer. Also,
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EAGAIN]]></c>.</p>
+          <c>erl_errno</c> is set to <c>EAGAIN</c>.</p>
         <p>On success, the message is placed in the specified buffer
           and the function returns the number of bytes actually read. On
           failure, the function returns a negative value and sets
-          <c><![CDATA[erl_errno]]></c> to one of:</p>
+          <c>erl_errno</c> to one of:</p>
         <taglist>
-          <tag><c><![CDATA[EAGAIN]]></c></tag>
+          <tag><c>EAGAIN</c></tag>
           <item>Temporary error: Try again.</item>
-          <tag><c><![CDATA[EMSGSIZE]]></c></tag>
+          <tag><c>EMSGSIZE</c></tag>
           <item>Buffer is too small.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
       </desc>
@@ -326,18 +326,18 @@ if (!erl_connect_init(17, "samplecookiestring...", 0))
       </type>
       <desc>
         <p>Receives the message into the specified buffer
-          and decodes into <c><![CDATA[(ErlMessage *) emsg]]></c>.</p>
+          and decodes into <c>(ErlMessage *) emsg</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[bufp]]></c> is a buffer large enough to hold the
+          <item><c>bufp</c> is a buffer large enough to hold the
             expected message.</item>
-          <item><c><![CDATA[bufsize]]></c> indicates the size of
-            <c><![CDATA[bufp]]></c>.</item>
-          <item>><c><![CDATA[emsg]]></c> is a pointer to an
-            <c><![CDATA[ErlMessage]]></c> structure
+          <item><c>bufsize</c> indicates the size of
+            <c>bufp</c>.</item>
+          <item>><c>emsg</c> is a pointer to an
+            <c>ErlMessage</c> structure
             into which the message will be decoded.
-            <c><![CDATA[ErlMessage]]></c> is defined as follows:</item>
+            <c>ErlMessage</c> is defined as follows:</item>
         </list>
         <code type="none"><![CDATA[
 typedef struct {
@@ -349,62 +349,62 @@ typedef struct {
 } ErlMessage;
         ]]></code>
         <note>
-          <p>The definition of <c><![CDATA[ErlMessage]]></c> has changed since
+          <p>The definition of <c>ErlMessage</c> has changed since
             earlier versions of <c>Erl_Interface</c>.</p>
         </note>
-        <p><c><![CDATA[type]]></c> identifies the type of message, one of the
+        <p><c>type</c> identifies the type of message, one of the
           following:</p>
         <taglist>
-          <tag><c><![CDATA[ERL_SEND]]></c></tag>
+          <tag><c>ERL_SEND</c></tag>
           <item>
             <p>An ordinary send operation has occurred and
-              <c><![CDATA[emsg->to]]></c> contains the pid of the recipient.
-              The message is in <c><![CDATA[emsg->msg]]></c>.</p>
+              <c>emsg->to</c> contains the pid of the recipient.
+              The message is in <c>emsg->msg</c>.</p>
           </item>
-          <tag><c><![CDATA[ERL_REG_SEND]]></c></tag>
+          <tag><c>ERL_REG_SEND</c></tag>
           <item>
             <p>A registered send operation has occurred and
-              <c><![CDATA[emsg->from]]></c> contains the pid of the sender.
-              The message is in <c><![CDATA[emsg->msg]]></c>.</p>
+              <c>emsg->from</c> contains the pid of the sender.
+              The message is in <c>emsg->msg</c>.</p>
           </item>
-          <tag><c><![CDATA[ERL_LINK]]></c> or <c><![CDATA[ERL_UNLINK]]></c>
+          <tag><c>ERL_LINK</c> or <c>ERL_UNLINK</c>
           </tag>
           <item>
-            <p><c><![CDATA[emsg->to]]></c> and <c><![CDATA[emsg->from]]></c>
+            <p><c>emsg->to</c> and <c>emsg->from</c>
               contain the pids of the sender and recipient of the link or
-              unlink. <c><![CDATA[emsg->msg]]></c> is not used.</p>
+              unlink. <c>emsg->msg</c> is not used.</p>
           </item>
-          <tag><c><![CDATA[ERL_EXIT]]></c></tag>
+          <tag><c>ERL_EXIT</c></tag>
           <item>
-            <p>A link is broken. <c><![CDATA[emsg->to]]></c> and
-              <c><![CDATA[emsg->from]]></c> contain the pids of the linked
-              processes, and <c><![CDATA[emsg->msg]]></c> contains the reason
+            <p>A link is broken. <c>emsg->to</c> and
+              <c>emsg->from</c> contain the pids of the linked
+              processes, and <c>emsg->msg</c> contains the reason
               for the exit.</p>
           </item>
         </taglist>
         <note>
           <p>It is the caller's responsibility to release the
-            memory pointed to by <c><![CDATA[emsg->msg]]></c>,
-            <c><![CDATA[emsg->to]]></c>, and
-            <c><![CDATA[emsg->from]]></c>.</p>
+            memory pointed to by <c>emsg->msg</c>,
+            <c>emsg->to</c>, and
+            <c>emsg->from</c>.</p>
         </note>
         <p>If a <em>tick</em> occurs, that is, the Erlang node on the
           other end of the connection has polled this node to see if it
-          is still alive, the function returns <c><![CDATA[ERL_TICK]]></c>
+          is still alive, the function returns <c>ERL_TICK</c>
           indicating that the tick has been received and responded to,
           but no message is placed in the buffer. In this case you
-          are to call <c><![CDATA[erl_receive_msg()]]></c> again.</p>
-        <p>On success, the function returns <c><![CDATA[ERL_MSG]]></c> and the
-          <c><![CDATA[Emsg]]></c> struct is initialized as described above, or
-          <c><![CDATA[ERL_TICK]]></c>, in which case no message is returned. On
-          failure, the function returns <c><![CDATA[ERL_ERROR]]></c> and sets
-          <c><![CDATA[erl_errno]]></c> to one of:</p>
+          are to call <c>erl_receive_msg()</c> again.</p>
+        <p>On success, the function returns <c>ERL_MSG</c> and the
+          <c>Emsg</c> struct is initialized as described above, or
+          <c>ERL_TICK</c>, in which case no message is returned. On
+          failure, the function returns <c>ERL_ERROR</c> and sets
+          <c>erl_errno</c> to one of:</p>
         <taglist>
-          <tag><c><![CDATA[EMSGSIZE]]></c></tag>
+          <tag><c>EMSGSIZE</c></tag>
           <item>Buffer is too small.</item>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
       </desc>
@@ -421,18 +421,18 @@ typedef struct {
       <desc>
         <p>Sends an Erlang term to a registered process.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[to]]></c> is a string containing the registered name
+          <item><c>to</c> is a string containing the registered name
             of the intended recipient of the message.</item>
-          <item><c><![CDATA[msg]]></c> is the Erlang term to be sent.</item>
+          <item><c>msg</c> is the Erlang term to be sent.</item>
         </list>
         <p>Returns <c>1</c> on success, otherwise <c>0</c>. In
-          the latter case <c><![CDATA[erl_errno]]></c> is set to one of:</p>
+          the latter case <c>erl_errno</c> is set to one of:</p>
         <taglist>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
       </desc>
@@ -451,60 +451,60 @@ typedef struct {
       </type>
       <desc>
         <p>Supports calling Erlang functions on remote nodes.
-          <c><![CDATA[erl_rpc_to()]]></c> sends an RPC request to a remote node
-          and <c><![CDATA[erl_rpc_from()]]></c> receives the results of such a
-          call. <c><![CDATA[erl_rpc()]]></c> combines the functionality of
+          <c>erl_rpc_to()</c> sends an RPC request to a remote node
+          and <c>erl_rpc_from()</c> receives the results of such a
+          call. <c>erl_rpc()</c> combines the functionality of
           these two functions by sending an RPC request and waiting for the
           results. See also <seealso marker="kernel:rpc#call/4">
           <c>rpc:call/4</c></seealso> in <c>Kernel</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[timeout]]></c> is the maximum time (in milliseconds)
+          <item><c>timeout</c> is the maximum time (in milliseconds)
             to wait for
-            results. To wait forever, specify <c><![CDATA[ERL_NO_TIMEOUT]]></c>.
+            results. To wait forever, specify <c>ERL_NO_TIMEOUT</c>.
             When <c>erl_rpc()</c> calls <c>erl_rpc_from()</c>, the call will
             never timeout.</item>
-          <item><c><![CDATA[mod]]></c> is the name of the module containing the
+          <item><c>mod</c> is the name of the module containing the
             function to be run on the remote node.</item>
-          <item><c><![CDATA[fun]]></c> is the name of the function to run.
+          <item><c>fun</c> is the name of the function to run.
           </item>
-          <item><c><![CDATA[args]]></c> is an Erlang list, containing the
+          <item><c>args</c> is an Erlang list, containing the
             arguments to be passed to the function.</item>
-          <item><c><![CDATA[emsg]]></c> is a message containing the result of
+          <item><c>emsg</c> is a message containing the result of
             the function call.</item>
         </list>
         <p>The actual message returned by the RPC server
-          is a 2-tuple <c><![CDATA[{rex,Reply}]]></c>. If you use
-          <c><![CDATA[erl_rpc_from()]]></c> in your code, this is the message
-          you will need to parse. If you use <c><![CDATA[erl_rpc()]]></c>, the
+          is a 2-tuple <c>{rex,Reply}</c>. If you use
+          <c>erl_rpc_from()</c> in your code, this is the message
+          you will need to parse. If you use <c>erl_rpc()</c>, the
           tuple itself is parsed for you, and the message returned to your
-          program is the Erlang term containing <c><![CDATA[Reply]]></c> only.
+          program is the Erlang term containing <c>Reply</c> only.
           Replies to RPC requests are always <c>ERL_SEND</c> messages.</p>
         <note>
           <p>It is the caller's responsibility to free the returned
-            <c><![CDATA[ETERM]]></c> structure and the memory pointed to by
-            <c><![CDATA[emsg->msg]]></c> and <c><![CDATA[emsg->to]]></c>.</p>
+            <c>ETERM</c> structure and the memory pointed to by
+            <c>emsg->msg</c> and <c>emsg->to</c>.</p>
         </note>
-        <p><c><![CDATA[erl_rpc()]]></c> returns the remote function's return
-          value on success, otherwise <c><![CDATA[NULL]]></c>.</p>
-        <p><c><![CDATA[erl_rpc_to()]]></c> returns <c>0</c> on
+        <p><c>erl_rpc()</c> returns the remote function's return
+          value on success, otherwise <c>NULL</c>.</p>
+        <p><c>erl_rpc_to()</c> returns <c>0</c> on
           success, otherwise a negative number.</p>
-        <p><c><![CDATA[erl_rcp_from()]]></c> returns <c><![CDATA[ERL_MSG]]></c>
-          on success (with <c><![CDATA[Emsg]]></c> now
+        <p><c>erl_rcp_from()</c> returns <c>ERL_MSG</c>
+          on success (with <c>Emsg</c> now
           containing the reply tuple), otherwise one of
-          <c><![CDATA[ERL_TICK]]></c>, <c><![CDATA[ERL_TIMEOUT]]></c>, or
-          <c><![CDATA[ERL_ERROR]]></c>.</p>
+          <c>ERL_TICK</c>, <c>ERL_TIMEOUT</c>, or
+          <c>ERL_ERROR</c>.</p>
         <p>When failing,
-          all three functions set <c><![CDATA[erl_errno]]></c> to one of:</p>
+          all three functions set <c>erl_errno</c> to one of:</p>
         <taglist>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
-          <tag><c><![CDATA[ETIMEDOUT]]></c></tag>
+          <tag><c>ETIMEDOUT</c></tag>
           <item>Timeout has expired.</item>
-          <tag><c><![CDATA[EAGAIN]]></c></tag>
+          <tag><c>EAGAIN</c></tag>
           <item>Temporary error: Try again.</item>
         </taglist>
       </desc>
@@ -520,21 +520,21 @@ typedef struct {
       <desc>
         <p>Sends an Erlang term to a process.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[to]]></c> is an Erlang term containing the pid of
+          <item><c>to</c> is an Erlang term containing the pid of
             the intended recipient of the message.</item>
-          <item>><c><![CDATA[msg]]></c> is the Erlang term to be sent.</item>
+          <item>><c>msg</c> is the Erlang term to be sent.</item>
         </list>
         <p>Returns <c>1</c> on success, otherwise <c>0</c>. In
-          the latter case <c><![CDATA[erl_errno]]></c> is set to one of:</p>
+          the latter case <c>erl_errno</c> is set to one of:</p>
         <taglist>
-          <tag><c><![CDATA[EINVAL]]></c></tag>
-          <item>Invalid argument: <c><![CDATA[to]]></c> is not a valid Erlang
+          <tag><c>EINVAL</c></tag>
+          <item>Invalid argument: <c>to</c> is not a valid Erlang
             pid.</item>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
       </desc>
@@ -550,8 +550,8 @@ typedef struct {
       <desc>
         <p>Retrieves information about
           the C-node. These values are initially set with
-          <c><![CDATA[erl_connect_init()]]></c> or
-          <c><![CDATA[erl_connect_xinit()]]></c>.</p>
+          <c>erl_connect_init()</c> or
+          <c>erl_connect_xinit()</c>.</p>
       </desc>
     </func>
 
@@ -568,17 +568,17 @@ typedef struct {
           <c>-relaxed_command_check</c>, which it normally is not.</p>
         <p>To unregister a node you have published, you should instead
           close the descriptor that was returned by
-          <c><![CDATA[ei_publish()]]></c>.</p>
+          <c>ei_publish()</c>.</p>
         <warning>
           <p>This function is deprecated and will be removed in a future
             release.</p>
         </warning>
-        <p><c><![CDATA[alive]]></c> is the name of the node to unregister, that
+        <p><c>alive</c> is the name of the node to unregister, that
           is, the first component of the node name, without
-          <c><![CDATA[@hostname]]></c>.</p>
+          <c>@hostname</c>.</p>
         <p>If the node was successfully unregistered from EPMD, <c>0</c> is
           returned, otherwise <c>-1</c> is returned and
-          <c><![CDATA[erl_errno]]></c> is set to <c><![CDATA[EIO]]></c>.</p>
+          <c>erl_errno</c> is set to <c>EIO</c>.</p>
       </desc>
     </func>
 
@@ -592,24 +592,24 @@ typedef struct {
         <v>ErlMessage *emsg;</v>
       </type>
       <desc>
-        <p>Similar to <c><![CDATA[erl_receive_msg]]></c>. The difference is
-          that <c><![CDATA[erl_xreceive_msg]]></c> expects the buffer to
-          have been allocated by <c><![CDATA[malloc]]></c>, and reallocates it
+        <p>Similar to <c>erl_receive_msg</c>. The difference is
+          that <c>erl_xreceive_msg</c> expects the buffer to
+          have been allocated by <c>malloc</c>, and reallocates it
           if the received
           message does not fit into the original buffer. Therefore
           both buffer and buffer length are given as pointers; their values
           can change by the call.</p>
-        <p>On success, the function returns <c><![CDATA[ERL_MSG]]></c> and the
-          <c><![CDATA[Emsg]]></c> struct is initialized as described above, or
-          <c><![CDATA[ERL_TICK]]></c>, in which case no message is returned. On
-          failure, the function returns <c><![CDATA[ERL_ERROR]]></c> and sets
-          <c><![CDATA[erl_errno]]></c> to one of:</p>
+        <p>On success, the function returns <c>ERL_MSG</c> and the
+          <c>Emsg</c> struct is initialized as described above, or
+          <c>ERL_TICK</c>, in which case no message is returned. On
+          failure, the function returns <c>ERL_ERROR</c> and sets
+          <c>erl_errno</c> to one of:</p>
         <taglist>
-          <tag><c><![CDATA[EMSGSIZE]]></c></tag>
+          <tag><c>EMSGSIZE</c></tag>
           <item>Buffer is too small.</item>
-          <tag><c><![CDATA[ENOMEM]]></c></tag>
+          <tag><c>ENOMEM</c></tag>
           <item>No more memory is available.</item>
-          <tag><c><![CDATA[EIO]]></c></tag>
+          <tag><c>EIO</c></tag>
           <item>I/O error.</item>
         </taglist>
       </desc>
@@ -643,11 +643,11 @@ typedef struct {
     <p>If a connection attempt fails, the following can be checked:</p>
 
     <list type="bulleted">
-      <item><c><![CDATA[erl_errno]]></c></item>
+      <item><c>erl_errno</c></item>
       <item>That the correct cookie was used</item>
       <item>That EPMD is running</item>
       <item>That the remote Erlang node on the other side is running the same
-        version of Erlang as the <c><![CDATA[erl_interface]]></c> library</item>
+        version of Erlang as the <c>erl_interface</c> library</item>
     </list>
   </section>
 </cref>
diff --git a/lib/erl_interface/doc/src/erl_error.xml b/lib/erl_interface/doc/src/erl_error.xml
index a85969d7ff..8139c9b343 100644
--- a/lib/erl_interface/doc/src/erl_error.xml
+++ b/lib/erl_interface/doc/src/erl_error.xml
@@ -40,9 +40,9 @@
       by W. Richard Stevens.</p>
 
     <p>These functions are all called in the same manner as
-      <c><![CDATA[printf()]]></c>, that is, with a string containing format
+      <c>printf()</c>, that is, with a string containing format
       specifiers followed by a list of corresponding arguments. All output from
-      these functions is to <c><![CDATA[stderr]]></c>.</p>
+      these functions is to <c>stderr</c>.</p>
   </description>
 
   <funcs>
@@ -54,7 +54,7 @@
       </type>
       <desc>
         <p>The message provided by the caller is printed. This
-          function is simply a wrapper for <c><![CDATA[fprintf()]]></c>.</p>
+          function is simply a wrapper for <c>fprintf()</c>.</p>
       </desc>
     </func>
 
@@ -105,37 +105,37 @@
     <title>Error Reporting</title>
     <p>Most functions in <c>Erl_Interface</c> report failures to the caller by
       returning some otherwise meaningless value (typically
-      <c><![CDATA[NULL]]></c>
+      <c>NULL</c>
       or a negative number). As this only tells you that things did not
-      go well, examine the error code in <c><![CDATA[erl_errno]]></c> if you
+      go well, examine the error code in <c>erl_errno</c> if you
       want to find out more about the failure.</p>
   </section>
 
   <funcs>
     <func>
       <name><ret>volatile int</ret><nametext>erl_errno</nametext></name>
-      <fsummary>Variable <c><![CDATA[erl_errno]]></c> contains the
+      <fsummary>Variable <c>erl_errno</c> contains the
         Erl_Interface error number. You can change the value if you wish.
       </fsummary>
       <desc>
-        <p><c><![CDATA[erl_errno]]></c> is initially (at program startup) zero
+        <p><c>erl_errno</c> is initially (at program startup) zero
           and is then set by many <c>Erl_Interface</c> functions on failure to
           a non-zero error code to indicate what kind of error it
           encountered. A successful function call can change
-          <c><![CDATA[erl_errno]]></c> (by calling some other function that
+          <c>erl_errno</c> (by calling some other function that
           fails), but no function does never set it to zero. This means
-          that you cannot use <c><![CDATA[erl_errno]]></c> to see <em>if</em> a
+          that you cannot use <c>erl_errno</c> to see <em>if</em> a
           function call failed. Instead, each function reports failure
           in its own way (usually by returning a negative number or
-          <c><![CDATA[NULL]]></c>), in which case you can examine
-          <c><![CDATA[erl_errno]]></c> for details.</p>
-        <p><c><![CDATA[erl_errno]]></c> uses the error codes defined in your
-          system's <c><![CDATA[<errno.h>]]></c>.</p>
+          <c>NULL</c>), in which case you can examine
+          <c>erl_errno</c> for details.</p>
+        <p><c>erl_errno</c> uses the error codes defined in your
+          system's <c>&lt;errno.h&gt;</c>.</p>
         <note>
-          <p><c><![CDATA[erl_errno]]></c> is a "modifiable lvalue" (just
-            like ISO C defines <c><![CDATA[errno]]></c> to be) rather than a
+          <p><c>erl_errno</c> is a "modifiable lvalue" (just
+            like ISO C defines <c>errno</c> to be) rather than a
             variable. This means it can be implemented as a macro
-            (expanding to, for example, <c><![CDATA[*_erl_errno()]]></c>).
+            (expanding to, for example, <c>*_erl_errno()</c>).
             For reasons of thread safety (or task safety), this is exactly what
             we do on most platforms.</p>
         </note>
diff --git a/lib/erl_interface/doc/src/erl_eterm.xml b/lib/erl_interface/doc/src/erl_eterm.xml
index e619232e4c..9a05196a70 100644
--- a/lib/erl_interface/doc/src/erl_eterm.xml
+++ b/lib/erl_interface/doc/src/erl_eterm.xml
@@ -39,7 +39,7 @@
       Erlang terms.</p>
 
     <p>An Erlang term is represented by a C structure of type
-      <c><![CDATA[ETERM]]></c>. Applications should not reference any fields
+      <c>ETERM</c>. Applications should not reference any fields
       in this structure directly, as it can be changed in future releases
       to provide faster and more compact term storage. Instead,
       applications should use the macros and functions provided.</p>
@@ -49,31 +49,31 @@
       otherwise <c>0</c>.</p>
 
     <taglist>
-      <tag><c><![CDATA[ERL_IS_INTEGER(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is an integer.</item>
-      <tag><c><![CDATA[ERL_IS_UNSIGNED_INTEGER(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is an integer.</item>
-      <tag><c><![CDATA[ERL_IS_FLOAT(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a floating point number.</item>
-      <tag><c><![CDATA[ERL_IS_ATOM(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is an atom.</item>
-      <tag><c><![CDATA[ERL_IS_PID(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a pid (process identifier).</item>
-      <tag><c><![CDATA[ERL_IS_PORT(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a port.</item>
-      <tag><c><![CDATA[ERL_IS_REF(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a reference.</item>
-      <tag><c><![CDATA[ERL_IS_TUPLE(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a tuple.</item>
-      <tag><c><![CDATA[ERL_IS_BINARY(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a binary.</item>
-      <tag><c><![CDATA[ERL_IS_LIST(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a list with zero or more
+      <tag><c>ERL_IS_INTEGER(t)</c></tag>
+      <item>True if <c>t</c> is an integer.</item>
+      <tag><c>ERL_IS_UNSIGNED_INTEGER(t)</c></tag>
+      <item>True if <c>t</c> is an integer.</item>
+      <tag><c>ERL_IS_FLOAT(t)</c></tag>
+      <item>True if <c>t</c> is a floating point number.</item>
+      <tag><c>ERL_IS_ATOM(t)</c></tag>
+      <item>True if <c>t</c> is an atom.</item>
+      <tag><c>ERL_IS_PID(t)</c></tag>
+      <item>True if <c>t</c> is a pid (process identifier).</item>
+      <tag><c>ERL_IS_PORT(t)</c></tag>
+      <item>True if <c>t</c> is a port.</item>
+      <tag><c>ERL_IS_REF(t)</c></tag>
+      <item>True if <c>t</c> is a reference.</item>
+      <tag><c>ERL_IS_TUPLE(t)</c></tag>
+      <item>True if <c>t</c> is a tuple.</item>
+      <tag><c>ERL_IS_BINARY(t)</c></tag>
+      <item>True if <c>t</c> is a binary.</item>
+      <tag><c>ERL_IS_LIST(t)</c></tag>
+      <item>True if <c>t</c> is a list with zero or more
         elements.</item>
-      <tag><c><![CDATA[ERL_IS_EMPTY_LIST(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is an empty list.</item>
-      <tag><c><![CDATA[ERL_IS_CONS(t)]]></c></tag>
-      <item>True if <c><![CDATA[t]]></c> is a list with at least one
+      <tag><c>ERL_IS_EMPTY_LIST(t)</c></tag>
+      <item>True if <c>t</c> is an empty list.</item>
+      <tag><c>ERL_IS_CONS(t)</c></tag>
+      <item>True if <c>t</c> is a list with at least one
         element.</item>
     </taglist>
 
@@ -83,60 +83,60 @@
       passing a tuple to <c>ERL_ATOM_PTR()</c> likely results in garbage.</p>
 
     <taglist>
-      <tag><c><![CDATA[char *ERL_ATOM_PTR(t)]]></c></tag>
+      <tag><c>char *ERL_ATOM_PTR(t)</c></tag>
       <item></item>
-      <tag><c><![CDATA[char *ERL_ATOM_PTR_UTF8(t)]]></c></tag>
-      <item>A string representing atom <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_ATOM_SIZE(t)]]></c></tag>
+      <tag><c>char *ERL_ATOM_PTR_UTF8(t)</c></tag>
+      <item>A string representing atom <c>t</c>.</item>
+      <tag><c>int ERL_ATOM_SIZE(t)</c></tag>
       <item></item>
-      <tag><c><![CDATA[int ERL_ATOM_SIZE_UTF8(t)]]></c></tag>
-      <item>The length (in bytes) of atom <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[void *ERL_BIN_PTR(t)]]></c></tag>
-      <item>A pointer to the contents of <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_BIN_SIZE(t)]]></c></tag>
-      <item>The length (in bytes) of binary object <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_INT_VALUE(t)]]></c></tag>
-      <item>The integer of <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[unsigned int ERL_INT_UVALUE(t)]]></c></tag>
-      <item>The unsigned integer value of <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[double ERL_FLOAT_VALUE(t)]]></c></tag>
-      <item>The floating point value of <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[ETERM *ERL_PID_NODE(t)]]></c></tag>
+      <tag><c>int ERL_ATOM_SIZE_UTF8(t)</c></tag>
+      <item>The length (in bytes) of atom <c>t</c>.</item>
+      <tag><c>void *ERL_BIN_PTR(t)</c></tag>
+      <item>A pointer to the contents of <c>t</c>.</item>
+      <tag><c>int ERL_BIN_SIZE(t)</c></tag>
+      <item>The length (in bytes) of binary object <c>t</c>.</item>
+      <tag><c>int ERL_INT_VALUE(t)</c></tag>
+      <item>The integer of <c>t</c>.</item>
+      <tag><c>unsigned int ERL_INT_UVALUE(t)</c></tag>
+      <item>The unsigned integer value of <c>t</c>.</item>
+      <tag><c>double ERL_FLOAT_VALUE(t)</c></tag>
+      <item>The floating point value of <c>t</c>.</item>
+      <tag><c>ETERM *ERL_PID_NODE(t)</c></tag>
       <item></item>
-      <tag><c><![CDATA[ETERM *ERL_PID_NODE_UTF8(t)]]></c></tag>
-      <item>The node in pid <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_PID_NUMBER(t)]]></c></tag>
-      <item>The sequence number in pid <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_PID_SERIAL(t)]]></c></tag>
-      <item>The serial number in pid <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_PID_CREATION(t)]]></c></tag>
-      <item>The creation number in pid <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_PORT_NUMBER(t)]]></c></tag>
-      <item>The sequence number in port <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_PORT_CREATION(t)]]></c></tag>
-      <item>The creation number in port <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[ETERM *ERL_PORT_NODE(t)]]></c></tag>
+      <tag><c>ETERM *ERL_PID_NODE_UTF8(t)</c></tag>
+      <item>The node in pid <c>t</c>.</item>
+      <tag><c>int ERL_PID_NUMBER(t)</c></tag>
+      <item>The sequence number in pid <c>t</c>.</item>
+      <tag><c>int ERL_PID_SERIAL(t)</c></tag>
+      <item>The serial number in pid <c>t</c>.</item>
+      <tag><c>int ERL_PID_CREATION(t)</c></tag>
+      <item>The creation number in pid <c>t</c>.</item>
+      <tag><c>int ERL_PORT_NUMBER(t)</c></tag>
+      <item>The sequence number in port <c>t</c>.</item>
+      <tag><c>int ERL_PORT_CREATION(t)</c></tag>
+      <item>The creation number in port <c>t</c>.</item>
+      <tag><c>ETERM *ERL_PORT_NODE(t)</c></tag>
       <item></item>
-      <tag><c><![CDATA[ETERM *ERL_PORT_NODE_UTF8(t)]]></c></tag>
-      <item>The node in port <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_REF_NUMBER(t)]]></c></tag>
-      <item>The first part of the reference number in ref <c><![CDATA[t]]></c>.
+      <tag><c>ETERM *ERL_PORT_NODE_UTF8(t)</c></tag>
+      <item>The node in port <c>t</c>.</item>
+      <tag><c>int ERL_REF_NUMBER(t)</c></tag>
+      <item>The first part of the reference number in ref <c>t</c>.
         Use only for compatibility.</item>
-      <tag><c><![CDATA[int ERL_REF_NUMBERS(t)]]></c></tag>
+      <tag><c>int ERL_REF_NUMBERS(t)</c></tag>
       <item>Pointer to the array of reference numbers in ref
-        <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_REF_LEN(t)]]></c></tag>
+        <c>t</c>.</item>
+      <tag><c>int ERL_REF_LEN(t)</c></tag>
       <item>The number of used reference numbers in ref
-        <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_REF_CREATION(t)]]></c></tag>
-      <item>The creation number in ref <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[int ERL_TUPLE_SIZE(t)]]></c></tag>
-      <item>The number of elements in tuple <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[ETERM *ERL_CONS_HEAD(t)]]></c></tag>
-      <item>The head element of list <c><![CDATA[t]]></c>.</item>
-      <tag><c><![CDATA[ETERM *ERL_CONS_TAIL(t)]]></c></tag>
+        <c>t</c>.</item>
+      <tag><c>int ERL_REF_CREATION(t)</c></tag>
+      <item>The creation number in ref <c>t</c>.</item>
+      <tag><c>int ERL_TUPLE_SIZE(t)</c></tag>
+      <item>The number of elements in tuple <c>t</c>.</item>
+      <tag><c>ETERM *ERL_CONS_HEAD(t)</c></tag>
+      <item>The head element of list <c>t</c>.</item>
+      <tag><c>ETERM *ERL_CONS_TAIL(t)</c></tag>
       <item>A list representing the tail elements of list
-        <c><![CDATA[t]]></c>.</item>
+        <c>t</c>.</item>
     </taglist>
   </description>
 
@@ -149,22 +149,22 @@
         <v>ETERM *tail;</v>
       </type>
       <desc>
-        <p>Concatenates two Erlang terms, prepending <c><![CDATA[head]]></c>
-          onto <c><![CDATA[tail]]></c> and thereby creating a
-          <c><![CDATA[cons]]></c> cell.
-          To make a proper list, <c><![CDATA[tail]]></c> is always to be a list
+        <p>Concatenates two Erlang terms, prepending <c>head</c>
+          onto <c>tail</c> and thereby creating a
+          <c>cons</c> cell.
+          To make a proper list, <c>tail</c> is always to be a list
           or an empty list. Notice that <c>NULL</c> is not a valid list.</p>
         <list type="bulleted">
-          <item><c><![CDATA[head]]></c> is the new term to be added.</item>
-          <item><c><![CDATA[tail]]></c> is the existing list to which
-            <c><![CDATA[head]]></c> is concatenated.</item>
+          <item><c>head</c> is the new term to be added.</item>
+          <item><c>tail</c> is the existing list to which
+            <c>head</c> is concatenated.</item>
         </list>
         <p>The function returns a new list.</p>
-        <p><c><![CDATA[ERL_CONS_HEAD(list)]]></c> and
-          <c><![CDATA[ERL_CONS_TAIL(list)]]></c>
+        <p><c>ERL_CONS_HEAD(list)</c> and
+          <c>ERL_CONS_TAIL(list)</c>
           can be used to retrieve the head and tail components
-          from the list. <c><![CDATA[erl_hd(list)]]></c> and
-          <c><![CDATA[erl_tl(list)]]></c> do
+          from the list. <c>erl_hd(list)</c> and
+          <c>erl_tl(list)</c> do
           the same thing, but check that the argument really is a list.</p>
         <p><em>Example:</em></p>
         <code type="none"><![CDATA[
@@ -188,7 +188,7 @@ erl_free_compound(list);
       </type>
       <desc>
         <p>Creates and returns a copy of the Erlang term
-          <c><![CDATA[term]]></c>.</p>
+          <c>term</c>.</p>
       </desc>
     </func>
 
@@ -202,15 +202,15 @@ erl_free_compound(list);
       <desc>
         <p>Extracts a specified element from an Erlang tuple.</p>
         <list type="bulleted">
-          <item><c><![CDATA[position]]></c> specifies which element to retrieve
-            from <c><![CDATA[tuple]]></c>. The elements are numbered starting
+          <item><c>position</c> specifies which element to retrieve
+            from <c>tuple</c>. The elements are numbered starting
             from 1.</item>
-          <item><c><![CDATA[tuple]]></c> is an Erlang term containing at least
-            <c><![CDATA[position]]></c> elements.</item>
+          <item><c>tuple</c> is an Erlang term containing at least
+            <c>position</c> elements.</item>
         </list>
         <p>Returns a new Erlang term corresponding to the requested element, or
-          <c>NULL</c> if <c><![CDATA[position]]></c> was greater
-          than the arity of <c><![CDATA[tuple]]></c>.</p>
+          <c>NULL</c> if <c>position</c> was greater
+          than the arity of <c>tuple</c>.</p>
       </desc>
     </func>
 
@@ -222,10 +222,10 @@ erl_free_compound(list);
       </type>
       <desc>
         <p>Extracts the first element from a list.</p>
-        <p><c><![CDATA[list]]></c> is an Erlang term containing a list.</p>
+        <p><c>list</c> is an Erlang term containing a list.</p>
         <p>Returns an Erlang term corresponding to the head
           head element in the list, or a <c>NULL</c> pointer if
-          <c><![CDATA[list]]></c> was not a list.</p>
+          <c>list</c> was not a list.</p>
       </desc>
     </func>
 
@@ -238,9 +238,9 @@ erl_free_compound(list);
       </type>
       <desc>
         <p>This function must be called before any of the others in the
-          <c><![CDATA[Erl_Interface]]></c> library to initialize the
+          <c>Erl_Interface</c> library to initialize the
           library functions. The arguments must be specified as
-          <c><![CDATA[erl_init(NULL,0)]]></c>.</p>
+          <c>erl_init(NULL,0)</c>.</p>
       </desc>
     </func>
 
@@ -252,9 +252,9 @@ erl_free_compound(list);
       </type>
       <desc>
         <p>Returns the length of an I/O list.</p>
-        <p><c><![CDATA[list]]></c> is an Erlang term containing an I/O list.</p>
-        <p>Returns the length of <c><![CDATA[list]]></c>, or
-          <c>-1</c> if <c><![CDATA[list]]></c> is not an I/O list.</p>
+        <p><c>list</c> is an Erlang term containing an I/O list.</p>
+        <p>Returns the length of <c>list</c>, or
+          <c>-1</c> if <c>list</c> is not an I/O list.</p>
         <p>For the definition of an I/O list, see
           <seealso marker="#erl_iolist_to_binary">
           <c>erl_iolist_to_binary</c></seealso>.</p>
@@ -269,9 +269,9 @@ erl_free_compound(list);
       </type>
       <desc>
         <p>Converts an I/O list to a binary term.</p>
-        <p><c><![CDATA[list]]></c> is an Erlang term containing a list.</p>
+        <p><c>list</c> is an Erlang term containing a list.</p>
         <p>Returns an Erlang binary term, or <c>NULL</c> if
-          <c><![CDATA[list]]></c> was not an I/O list.</p>
+          <c>list</c> was not an I/O list.</p>
         <p>Informally, an I/O list is a deep list of characters and
           binaries that can be sent to an Erlang port. In BNF, an I/O
           list is formally defined as follows:</p>
@@ -296,15 +296,15 @@ iohead ::= Binary
       </type>
       <desc>
           <p>Converts an I/O list to a <c>NULL</c>-terminated C string.</p>
-        <p><c><![CDATA[list]]></c> is an Erlang term containing an I/O list.
+        <p><c>list</c> is an Erlang term containing an I/O list.
           The I/O list must not contain the integer 0, as C strings may not
           contain this value except as a terminating marker.</p>
         <p>Returns a pointer to a dynamically allocated
-          buffer containing a string. If <c><![CDATA[list]]></c> is not an I/O
-          list, or if <c><![CDATA[list]]></c> contains the integer 0,
+          buffer containing a string. If <c>list</c> is not an I/O
+          list, or if <c>list</c> contains the integer 0,
           <c>NULL</c> is returned. It
           is the caller's responsibility to free the allocated buffer
-          with <c><![CDATA[erl_free()]]></c>.</p>
+          with <c>erl_free()</c>.</p>
         <p>For the definition of an I/O list, see
           <seealso marker="#erl_iolist_to_binary">
           <c>erl_iolist_to_binary</c></seealso>.</p>
@@ -319,10 +319,10 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Determines the length of a proper list.</p>
-        <p><c><![CDATA[list]]></c> is an Erlang term containing a proper list.
+        <p><c>list</c> is an Erlang term containing a proper list.
           In a proper list, all tails except the last point to another list
           cell, and the last tail points to an empty list.</p>
-        <p>Returns <c>-1</c> if <c><![CDATA[list]]></c> is not a proper
+        <p>Returns <c>-1</c> if <c>list</c> is not a proper
           list.</p>
       </desc>
     </func>
@@ -335,16 +335,16 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Creates an atom.</p>
-        <p><c><![CDATA[string]]></c> is the sequence of characters that will be
+        <p><c>string</c> is the sequence of characters that will be
           used to create the atom.</p>
         <p>Returns an Erlang term containing an atom. Notice that it is
-          the caller's responsibility to ensure that <c><![CDATA[string]]></c>
+          the caller's responsibility to ensure that <c>string</c>
           contains a valid name for an atom.</p>
-        <p><c><![CDATA[ERL_ATOM_PTR(atom)]]></c> and
-          <c><![CDATA[ERL_ATOM_PTR_UTF8(atom)]]></c>
+        <p><c>ERL_ATOM_PTR(atom)</c> and
+          <c>ERL_ATOM_PTR_UTF8(atom)</c>
           can be used to retrieve the atom name (as a <c>NULL</c>-terminated string).
-          <c><![CDATA[ERL_ATOM_SIZE(atom)]]></c>
-	  and <c><![CDATA[ERL_ATOM_SIZE_UTF8(atom)]]></c> return the length
+          <c>ERL_ATOM_SIZE(atom)</c>
+	  and <c>ERL_ATOM_SIZE_UTF8(atom)</c> return the length
           of the atom name.</p>
 	<note>
           <p>The UTF-8 variants were introduced in Erlang/OTP R16 and the
@@ -365,14 +365,14 @@ iohead ::= Binary
         <p>Produces an Erlang binary object from a
           buffer containing a sequence of bytes.</p>
         <list type="bulleted">
-          <item><c><![CDATA[bptr]]></c> is a pointer to a buffer containing
+          <item><c>bptr</c> is a pointer to a buffer containing
             data to be converted.</item>
-          <item><c><![CDATA[size]]></c> indicates the length of
-            <c><![CDATA[bptr]]></c>.</item>
+          <item><c>size</c> indicates the length of
+            <c>bptr</c>.</item>
         </list>
         <p>Returns an Erlang binary object.</p>
-        <p><c><![CDATA[ERL_BIN_PTR(bin)]]></c> retrieves a pointer to
-          the binary data. <c><![CDATA[ERL_BIN_SIZE(bin)]]></c> retrieves the
+        <p><c>ERL_BIN_PTR(bin)</c> retrieves a pointer to
+          the binary data. <c>ERL_BIN_SIZE(bin)</c> retrieves the
           size.</p>
       </desc>
     </func>
@@ -397,13 +397,13 @@ iohead ::= Binary
       <desc>
         <p>Creates a list from a sequence of bytes.</p>
         <list type="bulleted">
-          <item><c><![CDATA[string]]></c> is a buffer containing a sequence of
+          <item><c>string</c> is a buffer containing a sequence of
               bytes. The buffer does not need to be <c>NULL</c>-terminated.</item>
-          <item><c><![CDATA[len]]></c> is the length of
-            <c><![CDATA[string]]></c>.</item>
+          <item><c>len</c> is the length of
+            <c>string</c>.</item>
         </list>
         <p>Returns an Erlang list object corresponding to
-          the character sequence in <c><![CDATA[string]]></c>.</p>
+          the character sequence in <c>string</c>.</p>
       </desc>
     </func>
 
@@ -415,12 +415,12 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Creates an Erlang float.</p>
-        <p><c><![CDATA[f]]></c> is a value to be converted to an Erlang
+        <p><c>f</c> is a value to be converted to an Erlang
           float.</p>
         <p>Returns an Erlang float object with the value
-          specified in <c><![CDATA[f]]></c> or <c><![CDATA[NULL]]></c> if
-          <c><![CDATA[f]]></c> is not finite.</p>
-        <p><c><![CDATA[ERL_FLOAT_VALUE(t)]]></c> can be used to retrieve the
+          specified in <c>f</c> or <c>NULL</c> if
+          <c>f</c> is not finite.</p>
+        <p><c>ERL_FLOAT_VALUE(t)</c> can be used to retrieve the
           value from an Erlang float.</p>
       </desc>
     </func>
@@ -433,11 +433,11 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Creates an Erlang integer.</p>
-        <p><c><![CDATA[n]]></c> is a value to be converted to an Erlang
+        <p><c>n</c> is a value to be converted to an Erlang
           integer.</p>
         <p>Returns an Erlang integer object with the
-          value specified in <c><![CDATA[n]]></c>.</p>
-        <p><c><![CDATA[ERL_INT_VALUE(t)]]></c> can be used to retrieve the
+          value specified in <c>n</c>.</p>
+        <p><c>ERL_INT_VALUE(t)</c> can be used to retrieve the
           value from an Erlang integer.</p>
       </desc>
     </func>
@@ -454,13 +454,13 @@ iohead ::= Binary
           that each element in the list corresponds to one element in
           the array.</p>
         <list type="bulleted">
-          <item><c><![CDATA[array]]></c> is an array of Erlang terms.</item>
-          <item><c><![CDATA[arrsize]]></c> is the number of elements in
-            <c><![CDATA[array]]></c>.</item>
+          <item><c>array</c> is an array of Erlang terms.</item>
+          <item><c>arrsize</c> is the number of elements in
+            <c>array</c>.</item>
         </list>
         <p>The function creates an Erlang list object, whose length
-          <c><![CDATA[arrsize]]></c> and whose elements are taken from the
-          terms in <c><![CDATA[array]]></c>.</p>
+          <c>arrsize</c> and whose elements are taken from the
+          terms in <c>array</c>.</p>
       </desc>
     </func>
 
@@ -475,21 +475,21 @@ iohead ::= Binary
       <desc>
         <p>Creates an Erlang reference, with 82 bits.</p>
         <list type="bulleted">
-          <item><c><![CDATA[node]]></c> is the name of the C-node.</item>
-          <item><c><![CDATA[n1]]></c>, <c><![CDATA[n2]]></c>, and
-            <c><![CDATA[n3]]></c> can be seen as one big number
-            <c><![CDATA[n1*2^64+n2*2^32+n3]]></c>, which is to be chosen
+          <item><c>node</c> is the name of the C-node.</item>
+          <item><c>n1</c>, <c>n2</c>, and
+            <c>n3</c> can be seen as one big number
+            <c>n1*2^64+n2*2^32+n3</c>, which is to be chosen
             uniquely for each reference created for a given C-node.</item>
-          <item><c><![CDATA[creation]]></c> is an arbitrary number.</item>
+          <item><c>creation</c> is an arbitrary number.</item>
         </list>
-        <p>Notice that <c><![CDATA[n3]]></c> and <c><![CDATA[creation]]></c>
+        <p>Notice that <c>n3</c> and <c>creation</c>
           are limited in precision, so only the low 18 and 2 bits of these
           numbers are used.</p>
         <p>Returns an Erlang reference object.</p>
-        <p><c><![CDATA[ERL_REF_NODE(ref)]]></c>,
-          <c><![CDATA[ERL_REF_NUMBERS(ref)]]></c>,
-          <c><![CDATA[ERL_REF_LEN(ref)]]></c>, and
-          <c><![CDATA[ERL_REF_CREATION(ref)]]></c> can be used to retrieve the
+        <p><c>ERL_REF_NODE(ref)</c>,
+          <c>ERL_REF_NUMBERS(ref)</c>,
+          <c>ERL_REF_LEN(ref)</c>, and
+          <c>ERL_REF_CREATION(ref)</c> can be used to retrieve the
             values used to create the reference.</p>
       </desc>
     </func>
@@ -508,18 +508,18 @@ iohead ::= Binary
           resulting pid can be used by Erlang processes wishing to
           communicate with the C-node.</p>
         <list type="bulleted">
-          <item><c><![CDATA[node]]></c> is the name of the C-node.</item>
-          <item><c><![CDATA[number]]></c>, <c><![CDATA[serial]]></c>, and
-            <c><![CDATA[creation]]></c> are
+          <item><c>node</c> is the name of the C-node.</item>
+          <item><c>number</c>, <c>serial</c>, and
+            <c>creation</c> are
             arbitrary numbers. Notice that these are limited in
             precision, so only the low 15, 3, and 2 bits of these numbers
             are used.</item>
         </list>
         <p>Returns an Erlang pid object.</p>
-        <p><c><![CDATA[ERL_PID_NODE(pid)]]></c>,
-          <c><![CDATA[ERL_PID_NUMBER(pid)]]></c>,
-          <c><![CDATA[ERL_PID_SERIAL(pid)]]></c>, and
-          <c><![CDATA[ERL_PID_CREATION(pid)]]></c>
+        <p><c>ERL_PID_NODE(pid)</c>,
+          <c>ERL_PID_NUMBER(pid)</c>,
+          <c>ERL_PID_SERIAL(pid)</c>, and
+          <c>ERL_PID_CREATION(pid)</c>
           can be used to retrieve the four values used to create the pid.</p>
       </desc>
     </func>
@@ -535,16 +535,16 @@ iohead ::= Binary
       <desc>
         <p>Creates an Erlang port identifier.</p>
         <list type="bulleted">
-          <item><c><![CDATA[node]]></c> is the name of the C-node.</item>
-          <item><c><![CDATA[number]]></c> and <c><![CDATA[creation]]></c> are
+          <item><c>node</c> is the name of the C-node.</item>
+          <item><c>number</c> and <c>creation</c> are
             arbitrary numbers. Notice that these are limited in
             precision, so only the low 18 and 2 bits of these numbers
             are used.</item>
         </list>
         <p>Returns an Erlang port object.</p>
-        <p><c><![CDATA[ERL_PORT_NODE(port)]]></c>,
-          <c><![CDATA[ERL_PORT_NUMBER(port)]]></c>,
-          and <c><![CDATA[ERL_PORT_CREATION]]></c> can be used to retrieve the
+        <p><c>ERL_PORT_NODE(port)</c>,
+          <c>ERL_PORT_NUMBER(port)</c>,
+          and <c>ERL_PORT_CREATION</c> can be used to retrieve the
           three values used to create the port.</p>
       </desc>
     </func>
@@ -559,20 +559,20 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Creates an old Erlang reference, with
-          only 18 bits - use <c><![CDATA[erl_mk_long_ref]]></c> instead.</p>
+          only 18 bits - use <c>erl_mk_long_ref</c> instead.</p>
         <list type="bulleted">
-          <item><c><![CDATA[node]]></c> is the name of the C-node.</item>
-          <item><c><![CDATA[number]]></c> is to be chosen uniquely for each
+          <item><c>node</c> is the name of the C-node.</item>
+          <item><c>number</c> is to be chosen uniquely for each
             reference created for a given C-node.</item>
-          <item><c><![CDATA[creation]]></c> is an arbitrary number.</item>
+          <item><c>creation</c> is an arbitrary number.</item>
         </list>
-        <p>Notice that <c><![CDATA[number]]></c> and <c><![CDATA[creation]]></c>
+        <p>Notice that <c>number</c> and <c>creation</c>
           are limited in precision, so only the low 18 and 2 bits of these
           numbers are used.</p>
         <p>Returns an Erlang reference object.</p>
-        <p><c><![CDATA[ERL_REF_NODE(ref)]]></c>,
-          <c><![CDATA[ERL_REF_NUMBER(ref)]]></c>, and
-          <c><![CDATA[ERL_REF_CREATION(ref)]]></c> can be used to retrieve the
+        <p><c>ERL_REF_NODE(ref)</c>,
+          <c>ERL_REF_NUMBER(ref)</c>, and
+          <c>ERL_REF_CREATION(ref)</c> can be used to retrieve the
           three values used to create the reference.</p>
       </desc>
     </func>
@@ -585,7 +585,7 @@ iohead ::= Binary
       </type>
       <desc>
           <p>Creates a list from a <c>NULL</c>-terminated string.</p>
-          <p><c><![CDATA[string]]></c> is a <c>NULL</c>-terminated sequence of
+          <p><c>string</c> is a <c>NULL</c>-terminated sequence of
           characters
           (that is, a C string) from which the list will be created.</p>
         <p>Returns an Erlang list.</p>
@@ -602,20 +602,20 @@ iohead ::= Binary
       <desc>
         <p>Creates an Erlang tuple from an array of Erlang terms.</p>
         <list type="bulleted">
-          <item><c><![CDATA[array]]></c> is an array of Erlang terms.</item>
-          <item><c><![CDATA[arrsize]]></c> is the number of elements in
-            <c><![CDATA[array]]></c>.</item>
+          <item><c>array</c> is an array of Erlang terms.</item>
+          <item><c>arrsize</c> is the number of elements in
+            <c>array</c>.</item>
         </list>
         <p>The function creates an Erlang tuple, whose arity is
-          <c><![CDATA[size]]></c> and whose elements are taken from the terms
-          in <c><![CDATA[array]]></c>.</p>
+          <c>size</c> and whose elements are taken from the terms
+          in <c>array</c>.</p>
         <p>To retrieve the size of a tuple, either use function
-          <c><![CDATA[erl_size]]></c> (which checks the type of the
+          <c>erl_size</c> (which checks the type of the
           checked term and works for a binary as well as for a tuple) or
-          <c><![CDATA[ERL_TUPLE_SIZE(tuple)]]></c> returns the arity of a tuple.
-          <c><![CDATA[erl_size()]]></c> does the same thing, but it checks
+          <c>ERL_TUPLE_SIZE(tuple)</c> returns the arity of a tuple.
+          <c>erl_size()</c> does the same thing, but it checks
           that the argument is a tuple.
-          <c><![CDATA[erl_element(index,tuple)]]></c> returns the element
+          <c>erl_element(index,tuple)</c> returns the element
           corresponding to a given position in the tuple.</p>
       </desc>
     </func>
@@ -628,11 +628,11 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Creates an Erlang unsigned integer.</p>
-        <p><c><![CDATA[n]]></c> is a value to be converted to an Erlang
+        <p><c>n</c> is a value to be converted to an Erlang
           unsigned integer.</p>
         <p>Returns an Erlang unsigned integer object with
-          the value specified in <c><![CDATA[n]]></c>.</p>
-        <p><c><![CDATA[ERL_INT_UVALUE(t)]]></c> can be used to retrieve the
+          the value specified in <c>n</c>.</p>
+        <p><c>ERL_INT_UVALUE(t)</c> can be used to retrieve the
           value from an Erlang unsigned integer.</p>
       </desc>
     </func>
@@ -646,9 +646,9 @@ iohead ::= Binary
       <desc>
         <p>Creates an unbound Erlang variable. The variable can later be bound
           through pattern matching or assignment.</p>
-        <p><c><![CDATA[name]]></c> specifies a name for the variable.</p>
+        <p><c>name</c> specifies a name for the variable.</p>
         <p>Returns an Erlang variable object with the
-          name <c><![CDATA[name]]></c>.</p>
+          name <c>name</c>.</p>
       </desc>
     </func>
 
@@ -662,9 +662,9 @@ iohead ::= Binary
       <desc>
         <p>Prints the specified Erlang term to the specified output stream.</p>
         <list type="bulleted">
-          <item><c><![CDATA[stream]]></c> indicates where the function is to
+          <item><c>stream</c> indicates where the function is to
             send its output.</item>
-          <item><c><![CDATA[term]]></c> is the Erlang term to print.</item>
+          <item><c>term</c> is the Erlang term to print.</item>
         </list>
         <p>Returns the number of characters written on success, otherwise a
           negative value.</p>
@@ -678,16 +678,16 @@ iohead ::= Binary
         <v>unsigned release_number;</v>
       </type>
       <desc>
-        <p>By default, the <c><![CDATA[Erl_Interface]]></c> library is only
+        <p>By default, the <c>Erl_Interface</c> library is only
           guaranteed to be compatible with other Erlang/OTP components from the
-          same release as the <c><![CDATA[Erl_Interface]]></c> library itself.
-          For example, <c><![CDATA[Erl_Interface]]></c> from Erlang/OTP R10
+          same release as the <c>Erl_Interface</c> library itself.
+          For example, <c>Erl_Interface</c> from Erlang/OTP R10
           is not compatible
           with an Erlang emulator from Erlang/OTP R9 by default.</p>
-        <p>A call to <c><![CDATA[erl_set_compat_rel(release_number)]]></c> sets
-          the <c><![CDATA[Erl_Interface]]></c> library in compatibility mode of
-          release <c><![CDATA[release_number]]></c>. Valid range of
-          <c><![CDATA[release_number]]></c>
+        <p>A call to <c>erl_set_compat_rel(release_number)</c> sets
+          the <c>Erl_Interface</c> library in compatibility mode of
+          release <c>release_number</c>. Valid range of
+          <c>release_number</c>
           is [7, current release]. This makes it possible to
           communicate with Erlang/OTP components from earlier releases.</p>
         <note>
@@ -714,10 +714,10 @@ iohead ::= Binary
       <desc>
         <p>Returns either the arity of an Erlang tuple or the
           number of bytes in an Erlang binary object.</p>
-        <p><c><![CDATA[term]]></c> is an Erlang tuple or an Erlang binary
+        <p><c>term</c> is an Erlang tuple or an Erlang binary
           object.</p>
-        <p>Returns the size of <c><![CDATA[term]]></c> as described
-          above, or <c>-1</c> if <c><![CDATA[term]]></c> is not one of the two
+        <p>Returns the size of <c>term</c> as described
+          above, or <c>-1</c> if <c>term</c> is not one of the two
           supported types.</p>
       </desc>
     </func>
@@ -730,10 +730,10 @@ iohead ::= Binary
       </type>
       <desc>
         <p>Extracts the tail from a list.</p>
-        <p><c><![CDATA[list]]></c> is an Erlang term containing a list.</p>
+        <p><c>list</c> is an Erlang term containing a list.</p>
         <p>Returns an Erlang list corresponding to the
           original list minus the first element, or <c>NULL</c> pointer if
-          <c><![CDATA[list]]></c> was not a list.</p>
+          <c>list</c> was not a list.</p>
       </desc>
     </func>
 
@@ -747,19 +747,19 @@ iohead ::= Binary
       <desc>
         <p>Returns the contents of the specified variable in an Erlang term.</p>
         <list type="bulleted">
-          <item><c><![CDATA[term]]></c> is an Erlang term. In order for this
+          <item><c>term</c> is an Erlang term. In order for this
             function to succeed,
-            <c><![CDATA[term]]></c> must either be an Erlang variable with
+            <c>term</c> must either be an Erlang variable with
             the specified name, or it must be an Erlang list or tuple
             containing a variable with the specified name. Other Erlang
             types cannot contain variables.</item>
-          <item><c><![CDATA[name]]></c> is the name of an Erlang variable.
+          <item><c>name</c> is the name of an Erlang variable.
           </item>
         </list>
         <p>Returns the Erlang object corresponding to the value of
-          <c><![CDATA[name]]></c> in <c><![CDATA[term]]></c>. If no variable
-          with the name <c><![CDATA[name]]></c> is found in
-          <c><![CDATA[term]]></c>, or if <c><![CDATA[term]]></c> is
+          <c>name</c> in <c>term</c>. If no variable
+          with the name <c>name</c> is found in
+          <c>term</c>, or if <c>term</c> is
           not a valid Erlang term, <c>NULL</c> is returned.</p>
       </desc>
     </func>
diff --git a/lib/erl_interface/doc/src/erl_format.xml b/lib/erl_interface/doc/src/erl_format.xml
index f6f27326ff..5b8b7b5e78 100644
--- a/lib/erl_interface/doc/src/erl_format.xml
+++ b/lib/erl_interface/doc/src/erl_format.xml
@@ -49,8 +49,8 @@
       <desc>
         <p>A general function for creating Erlang terms using
           a format specifier and a corresponding set of arguments, much
-          in the way <c><![CDATA[printf()]]></c> works.</p>
-        <p><c><![CDATA[FormatStr]]></c> is a format specification string.
+          in the way <c>printf()</c> works.</p>
+        <p><c>FormatStr</c> is a format specification string.
           The valid format specifiers are as follows:</p>
         <list type="bulleted">
           <item><c>~i</c> - Integer</item>
@@ -59,10 +59,10 @@
           <item><c>~s</c> - String</item>
           <item><c>~w</c> - Arbitrary Erlang term</item>
         </list>
-        <p>For each format specifier included in <c><![CDATA[FormatStr]]></c>,
+        <p>For each format specifier included in <c>FormatStr</c>,
           there must be a corresponding argument following
-          <c><![CDATA[FormatStr]]></c>. An Erlang term is built according to
-          <c><![CDATA[FormatStr]]></c> with values and Erlang terms substituted
+          <c>FormatStr</c>. An Erlang term is built according to
+          <c>FormatStr</c> with values and Erlang terms substituted
           from the corresponding arguments, and according to the individual
           format specifiers. For example:</p>
         <code type="none"><![CDATA[
@@ -71,11 +71,11 @@ erl_format("[{name,~a},{age,~i},{data,~w}]",
            21,
            erl_format("[{adr,~s,~i}]","E-street",42));
         ]]></code>
-        <p>This creates an <c><![CDATA[(ETERM *)]]></c> structure corresponding
+        <p>This creates an <c>(ETERM *)</c> structure corresponding
           to the Erlang term
-          <c><![CDATA[[{name,madonna},{age,21},{data,[{adr,"E-street",42}]}]]]></c></p>
+          <c>[{name,madonna},{age,21},{data,[{adr,"E-street",42}]}]</c></p>
         <p>The function returns an Erlang term, or <c>NULL</c> if
-          <c><![CDATA[FormatStr]]></c> does not describe a valid Erlang
+          <c>FormatStr</c> does not describe a valid Erlang
           term.</p>
       </desc>
     </func>
@@ -92,18 +92,18 @@ erl_format("[{name,~a},{age,~i},{data,~w}]",
           section <seealso marker="doc/reference_manual:patterns">
           Pattern Matching</seealso> in the Erlang Reference Manual.</p>
         <list type="bulleted">
-          <item><c><![CDATA[Pattern]]></c> is an Erlang term, possibly
+          <item><c>Pattern</c> is an Erlang term, possibly
             containing unbound variables.</item>
-          <item><c><![CDATA[Term]]></c> is an Erlang term that we wish to match
-            against <c><![CDATA[Pattern]]></c>.</item>
+          <item><c>Term</c> is an Erlang term that we wish to match
+            against <c>Pattern</c>.</item>
         </list>
-        <p><c><![CDATA[Term]]></c> and <c><![CDATA[Pattern]]></c> are compared
-          and any unbound variables in <c><![CDATA[Pattern]]></c> are bound to
-          corresponding values in <c><![CDATA[Term]]></c>.</p>
-        <p>If <c><![CDATA[Term]]></c> and <c><![CDATA[Pattern]]></c> can be
+        <p><c>Term</c> and <c>Pattern</c> are compared
+          and any unbound variables in <c>Pattern</c> are bound to
+          corresponding values in <c>Term</c>.</p>
+        <p>If <c>Term</c> and <c>Pattern</c> can be
           matched, the function returns a non-zero value and binds any unbound
-          variables in <c><![CDATA[Pattern]]></c>. If <c><![CDATA[Term]]></c>
-          and <c><![CDATA[Pattern]]></c> do
+          variables in <c>Pattern</c>. If <c>Term</c>
+          and <c>Pattern</c> do
           not match, <c>0</c> is returned. For example:</p>
         <code type="none"><![CDATA[
 ETERM *term, *pattern, *pattern2;
@@ -129,9 +129,9 @@ if (erl_match(pattern2, term2)) {
   ...
 }
         ]]></code>
-        <p><c><![CDATA[erl_var_content()]]></c> can be used to retrieve the
+        <p><c>erl_var_content()</c> can be used to retrieve the
           content of any variables bound as a result of a call to
-          <c><![CDATA[erl_match()]]></c>.</p>
+          <c>erl_match()</c>.</p>
       </desc>
     </func>
   </funcs>
diff --git a/lib/erl_interface/doc/src/erl_global.xml b/lib/erl_interface/doc/src/erl_global.xml
index 0808ea0eee..2fa0045adf 100644
--- a/lib/erl_interface/doc/src/erl_global.xml
+++ b/lib/erl_interface/doc/src/erl_global.xml
@@ -57,23 +57,23 @@
       <desc>
         <p>Retrieves a list of all known global names.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[count]]></c> is the address of an integer, or
-            <c>NULL</c>. If <c><![CDATA[count]]></c> is not <c>NULL</c>, it is
+          <item><c>count</c> is the address of an integer, or
+            <c>NULL</c>. If <c>count</c> is not <c>NULL</c>, it is
             set by the function to the number of names found.</item>
         </list>
         <p>On success, the function returns an array of strings, each
           containing a single registered name, and sets
-          <c><![CDATA[count]]></c> to
+          <c>count</c> to
           the number of names found. The array is terminated
           by a single <c>NULL</c> pointer. On failure, the function returns
-          <c>NULL</c> and <c><![CDATA[count]]></c> is not modified.</p>
+          <c>NULL</c> and <c>count</c> is not modified.</p>
         <note>
           <p>It is the caller's responsibility to free the array
             afterwards. It has been allocated by the function with a
-            single call to <c><![CDATA[malloc()]]></c>, so a single
-            <c><![CDATA[free()]]></c> is all that is necessary.</p>
+            single call to <c>malloc()</c>, so a single
+            <c>free()</c> is all that is necessary.</p>
         </note>
       </desc>
     </func>
@@ -89,13 +89,13 @@
       <desc>
         <p>Registers a name in <c>global</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[name]]></c> is the name to register in
+          <item><c>name</c> is the name to register in
             <c>global</c>.</item>
-          <item><c><![CDATA[pid]]></c> is the pid that is to be associated with
-            <c><![CDATA[name]]></c>. This value is returned by <c>global</c>
-            when processes request the location of <c><![CDATA[name]]></c>.
+          <item><c>pid</c> is the pid that is to be associated with
+            <c>name</c>. This value is returned by <c>global</c>
+            when processes request the location of <c>name</c>.
           </item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
@@ -112,9 +112,9 @@
       <desc>
         <p>Unregisters a name from <c>global</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[name]]></c> is the name to unregister from
+          <item><c>name</c> is the name to unregister from
             <c>global</c>.</item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
@@ -132,19 +132,19 @@
       <desc>
         <p>Looks up a name in <c>global</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open descriptor to an Erlang
+          <item><c>fd</c> is an open descriptor to an Erlang
             connection.</item>
-          <item><c><![CDATA[name]]></c> is the name that is to be looked up in
+          <item><c>name</c> is the name that is to be looked up in
             <c>global</c>.</item>
         </list>
-        <p>If <c><![CDATA[node]]></c> is not <c>NULL</c>, it is a pointer to a
+        <p>If <c>node</c> is not <c>NULL</c>, it is a pointer to a
           buffer where the function can fill in the name of the node where
-          <c><![CDATA[name]]></c> is found. <c><![CDATA[node]]></c> can be
-          passed directly to <c><![CDATA[erl_connect()]]></c> if necessary.</p>
+          <c>name</c> is found. <c>node</c> can be
+          passed directly to <c>erl_connect()</c> if necessary.</p>
         <p>On success, the function returns an Erlang pid containing the address
           of the specified name, and the node is initialized to
-          the node name where <c><![CDATA[name]]></c> is found. On failure,
-          <c>NULL</c> is returned and <c><![CDATA[node]]></c> is not
+          the node name where <c>name</c> is found. On failure,
+          <c>NULL</c> is returned and <c>node</c> is not
           modified.</p>
       </desc>
     </func>
diff --git a/lib/erl_interface/doc/src/erl_interface.xml b/lib/erl_interface/doc/src/erl_interface.xml
index ab5b46cc01..4e66655b39 100644
--- a/lib/erl_interface/doc/src/erl_interface.xml
+++ b/lib/erl_interface/doc/src/erl_interface.xml
@@ -72,51 +72,51 @@ Eshell V4.7.4  (abort with ^G)
 1> code:root_dir().
 /usr/local/otp    ]]></code>
     <p>To compile your code, make sure that your C compiler knows where
-      to find <c><![CDATA[erl_interface.h]]></c> by specifying an appropriate <c><![CDATA[-I]]></c>
-      argument on the command line, or by adding it to the <c><![CDATA[CFLAGS]]></c>
-      definition in your <c><![CDATA[Makefile]]></c>. The correct value for this path is
-      <c><![CDATA[$OTPROOT/lib/erl_interface]]></c><em>Vsn</em><c><![CDATA[/include]]></c>, where <c><![CDATA[$OTPROOT]]></c> is the path
-      reported by <c><![CDATA[code:root_dir/0]]></c> in the above example, and <em>Vsn</em> is
+      to find <c>erl_interface.h</c> by specifying an appropriate <c>-I</c>
+      argument on the command line, or by adding it to the <c>CFLAGS</c>
+      definition in your <c>Makefile</c>. The correct value for this path is
+      <c>$OTPROOT/lib/erl_interface</c><em>Vsn</em><c>/include</c>, where <c>$OTPROOT</c> is the path
+      reported by <c>code:root_dir/0</c> in the above example, and <em>Vsn</em> is
       the version of the Erl_interface application, for example 
-      <c><![CDATA[erl_interface-3.2.3]]></c></p>
+      <c>erl_interface-3.2.3</c></p>
     <code type="none"><![CDATA[
 $ cc -c -I/usr/local/otp/lib/erl_interface-3.2.3/include myprog.c    ]]></code>
     <p>When linking, you will need to specify the path to
-      <c><![CDATA[liberl_interface.a]]></c> and <c><![CDATA[libei.a]]></c> with
-      <c><![CDATA[-L$OTPROOT/lib/erl_interface-3.2.3/lib]]></c>, and you will need to specify the
-      name of the libraries with <c><![CDATA[-lerl_interface -lei]]></c>. You can do
-      this on the command line or by adding the flags to the <c><![CDATA[LDFLAGS]]></c>
-      definition in your <c><![CDATA[Makefile]]></c>.</p>
+      <c>liberl_interface.a</c> and <c>libei.a</c> with
+      <c>-L$OTPROOT/lib/erl_interface-3.2.3/lib</c>, and you will need to specify the
+      name of the libraries with <c>-lerl_interface -lei</c>. You can do
+      this on the command line or by adding the flags to the <c>LDFLAGS</c>
+      definition in your <c>Makefile</c>.</p>
     <code type="none"><![CDATA[
 $ ld -L/usr/local/otp/lib/erl_interface-3.2.3/
                             lib myprog.o -lerl_interface -lei -o myprog    ]]></code>
     <p>Also, on some systems it may be necessary to link with some
-      additional libraries (e.g. <c><![CDATA[libnsl.a]]></c> and <c><![CDATA[libsocket.a]]></c> on
-      Solaris, or <c><![CDATA[wsock32.lib]]></c> on Windows) in order to use the
+      additional libraries (e.g. <c>libnsl.a</c> and <c>libsocket.a</c> on
+      Solaris, or <c>wsock32.lib</c> on Windows) in order to use the
       communication facilities of Erl_Interface.</p>
     <p>If you are using Erl_Interface functions in a threaded
       application based on POSIX threads or Solaris threads, then
       Erl_Interface needs access to some of the synchronization
       facilities in your threads package, and you will need to specify
       additional compiler flags in order to indicate which of the packages
-      you are using. Define <c><![CDATA[_REENTRANT]]></c> and either <c><![CDATA[STHREADS]]></c> or
-      <c><![CDATA[PTHREADS]]></c>. The default is to use POSIX threads if
-      <c><![CDATA[_REENTRANT]]></c> is specified.</p>
+      you are using. Define <c>_REENTRANT</c> and either <c>STHREADS</c> or
+      <c>PTHREADS</c>. The default is to use POSIX threads if
+      <c>_REENTRANT</c> is specified.</p>
     <p>Note that both single threaded and default versions of the Erl_interface 
       and Ei libraries are provided. (The single threaded versions are named 
-      <c><![CDATA[liberl_interface_st]]></c> and <c><![CDATA[libei_st]]></c>). Whether the default
+      <c>liberl_interface_st</c> and <c>libei_st</c>). Whether the default
       versions of the libraries have support for threads or not is determined by if 
       the platform in question has support for POSIX or Solaris threads. To check this, 
-      have a look in the <c><![CDATA[eidefs.mk]]></c> file in the erl_interface src directory.</p>
+      have a look in the <c>eidefs.mk</c> file in the erl_interface src directory.</p>
   </section>
 
   <section>
     <title>Initializing the erl_interface Library</title>
     <p>Before calling any of the other Erl_Interface functions, you
-      must call <c><![CDATA[erl_init()]]></c> exactly once to initialize the library.
-      <c><![CDATA[erl_init()]]></c> takes two arguments, however the arguments are no
+      must call <c>erl_init()</c> exactly once to initialize the library.
+      <c>erl_init()</c> takes two arguments, however the arguments are no
       longer used by Erl_Interface, and should therefore be specified
-      as <c><![CDATA[erl_init(NULL,0)]]></c>.</p>
+      as <c>erl_init(NULL,0)</c>.</p>
   </section>
 
   <section>
@@ -129,7 +129,7 @@ $ ld -L/usr/local/otp/lib/erl_interface-3.2.3/
       number of C functions which create and manipulate Erlang data
       structures. The library also contains an encode and a decode function.
       The example below shows how to create and encode an Erlang tuple
-      <c><![CDATA[{tobbe,3928}]]></c>:</p>
+      <c>{tobbe,3928}</c>:</p>
     <code type="none"><![CDATA[
 
 ETERM *arr[2], *tuple;
@@ -140,26 +140,26 @@ arr[0] = erl_mk_atom("tobbe");
 arr[1] = erl_mk_integer(3928);
 tuple  = erl_mk_tuple(arr, 2);
 i = erl_encode(tuple, buf);    ]]></code>
-    <p>Alternatively, you can use <c><![CDATA[erl_send()]]></c> and
-      <c><![CDATA[erl_receive_msg]]></c>, which handle the encoding and decoding of
+    <p>Alternatively, you can use <c>erl_send()</c> and
+      <c>erl_receive_msg</c>, which handle the encoding and decoding of
       messages transparently.</p>
     <p>Refer to the Reference Manual for a complete description of the
       following modules:</p>
     <list type="bulleted">
-      <item>the <c><![CDATA[erl_eterm]]></c> module for creating Erlang terms</item>
-      <item>the <c><![CDATA[erl_marshal]]></c> module for encoding and decoding routines.</item>
+      <item>the <c>erl_eterm</c> module for creating Erlang terms</item>
+      <item>the <c>erl_marshal</c> module for encoding and decoding routines.</item>
     </list>
   </section>
 
   <section>
     <title>Building Terms and Patterns</title>
     <p>The previous example can be simplified by using
-      <c><![CDATA[erl_format()]]></c> to create an Erlang term.</p>
+      <c>erl_format()</c> to create an Erlang term.</p>
     <code type="none"><![CDATA[
 
 ETERM *ep;
 ep = erl_format("{~a,~i}", "tobbe", 3928);    ]]></code>
-    <p>Refer to the Reference Manual, the <c><![CDATA[erl_format]]></c> module, for a
+    <p>Refer to the Reference Manual, the <c>erl_format</c> module, for a
       full description of the different format directives. The following
       example is more complex:</p>
     <code type="none"><![CDATA[
@@ -172,9 +172,9 @@ ep = erl_format("[{name,~a},{age,~i},{data,~w}]",
 erl_free_compound(ep);      ]]></code>
     <p>As in previous examples, it is your responsibility to free the
       memory allocated for Erlang terms. In this example,
-      <c><![CDATA[erl_free_compound()]]></c> ensures that the complete term pointed to
-      by <c><![CDATA[ep]]></c> is released. This is necessary, because the pointer from
-      the second call to <c><![CDATA[erl_format()]]></c> is lost. </p>
+      <c>erl_free_compound()</c> ensures that the complete term pointed to
+      by <c>ep</c> is released. This is necessary, because the pointer from
+      the second call to <c>erl_format()</c> is lost. </p>
     <p>The following
       example shows a slightly different solution:</p>
     <code type="none"><![CDATA[
@@ -186,7 +186,7 @@ ep  = erl_format("[{name,~a},{age,~i},{data,~w}]",
 erl_free_term(ep);  
 erl_free_term(ep2);      ]]></code>
     <p>In this case, you free the two terms independently. The order in
-      which you free the terms <c><![CDATA[ep]]></c> and <c><![CDATA[ep2]]></c> is not important,
+      which you free the terms <c>ep</c> and <c>ep2</c> is not important,
       because the Erl_Interface library uses reference counting to
       determine when it is safe to actually remove objects. </p>
     <p>If you are not sure whether you have freed the terms properly, you
@@ -204,14 +204,14 @@ printf("length of freelist: %ld\
 /* really free the freelist */
 erl_eterm_release();
     ]]></code>
-    <p>Refer to the Reference Manual, the <c><![CDATA[erl_malloc]]></c> module for more
+    <p>Refer to the Reference Manual, the <c>erl_malloc</c> module for more
       information.</p>
   </section>
 
   <section>
     <title>Pattern Matching</title>
     <p>An Erlang pattern is a term that may contain unbound variables or
-      <c><![CDATA["do not care"]]></c> symbols. Such a pattern can be matched against a
+      <c>"do not care"</c> symbols. Such a pattern can be matched against a
       term and, if the match is successful, any unbound variables in the
       pattern will be bound as a side effect. The content of a bound
       variable can then be retrieved.</p>
@@ -219,13 +219,13 @@ erl_eterm_release();
 
 ETERM *pattern;
 pattern = erl_format("{madonna,Age,_}");    ]]></code>
-    <p><c><![CDATA[erl_match()]]></c> is used to perform pattern matching. It takes a
+    <p><c>erl_match()</c> is used to perform pattern matching. It takes a
       pattern and a term and tries to match them. As a side effect any unbound
       variables in the pattern will be bound. In the following example, we
       create a pattern with a variable <em>Age</em> which appears at two
       positions in the tuple. The pattern match is performed as follows:</p>
     <list type="ordered">
-      <item><c><![CDATA[erl_match()]]></c> will bind the contents of
+      <item><c>erl_match()</c> will bind the contents of
       <em>Age</em> to <em>21</em> the first time it reaches the variable</item>
       <item>the second occurrence of <em>Age</em> will cause a test for
        equality between the terms since <em>Age</em> is already bound to
@@ -248,14 +248,14 @@ if (erl_match(pattern, term)) {
 }
 erl_free_term(pattern);
 erl_free_term(term);    ]]></code>
-    <p>Refer to the Reference Manual, the <c><![CDATA[erl_match()]]></c> function for
+    <p>Refer to the Reference Manual, the <c>erl_match()</c> function for
       more information.</p>
   </section>
 
   <section>
     <title>Connecting to a Distributed Erlang Node</title>
     <p>In order to connect to a distributed Erlang node you need to first
-      initialize the connection routine with <c><![CDATA[erl_connect_init()]]></c>,
+      initialize the connection routine with <c>erl_connect_init()</c>,
       which stores information such as the host name, node name, and IP
       address for later use:</p>
     <code type="none"><![CDATA[
@@ -263,9 +263,9 @@ int identification_number = 99;
 int creation=1;
 char *cookie="a secret cookie string"; /* An example */
 erl_connect_init(identification_number, cookie, creation);    ]]></code>
-    <p>Refer to the Reference Manual, the <c><![CDATA[erl_connect]]></c> module for more information.</p>
+    <p>Refer to the Reference Manual, the <c>erl_connect</c> module for more information.</p>
     <p>After initialization, you set up the connection to the Erlang node.
-      Use <c><![CDATA[erl_connect()]]></c> to specify the Erlang node you want to
+      Use <c>erl_connect()</c> to specify the Erlang node you want to
       connect to. The following example sets up the connection and should
       result in a valid socket file descriptor:</p>
     <code type="none"><![CDATA[
@@ -273,45 +273,45 @@ int sockfd;
 char *nodename="[email protected]"; /* An example */
 if ((sockfd = erl_connect(nodename)) < 0)
   erl_err_quit("ERROR: erl_connect failed");    ]]></code>
-    <p><c><![CDATA[erl_err_quit()]]></c> prints the specified string and terminates
-      the program. Refer to the Reference Manual, the <c><![CDATA[erl_error()]]></c>
+    <p><c>erl_err_quit()</c> prints the specified string and terminates
+      the program. Refer to the Reference Manual, the <c>erl_error()</c>
       function for more information.</p>
   </section>
 
   <section>
     <title>Using EPMD</title>
-    <p><c><![CDATA[Epmd]]></c> is the Erlang Port Mapper Daemon. Distributed Erlang nodes
-      register with <c><![CDATA[epmd]]></c> on the localhost to indicate to other nodes that
-      they exist and can accept connections. <c><![CDATA[Epmd]]></c> maintains a register of
+    <p><c>Epmd</c> is the Erlang Port Mapper Daemon. Distributed Erlang nodes
+      register with <c>epmd</c> on the localhost to indicate to other nodes that
+      they exist and can accept connections. <c>Epmd</c> maintains a register of
       node and port number information, and when a node wishes to connect to
-      another node, it first contacts <c><![CDATA[epmd]]></c> in order to find out the correct
+      another node, it first contacts <c>epmd</c> in order to find out the correct
       port number to connect to.</p>
-    <p>When you use <c><![CDATA[erl_connect()]]></c> to connect to an Erlang node, a
-      connection is first made to <c><![CDATA[epmd]]></c> and, if the node is known, a
+    <p>When you use <c>erl_connect()</c> to connect to an Erlang node, a
+      connection is first made to <c>epmd</c> and, if the node is known, a
       connection is then made to the Erlang node.</p>
-    <p>C nodes can also register themselves with <c><![CDATA[epmd]]></c> if they want other
+    <p>C nodes can also register themselves with <c>epmd</c> if they want other
       nodes in the system to be able to find and connect to them.</p>
-    <p>Before registering with <c><![CDATA[epmd]]></c>, you need to first create a listen socket
+    <p>Before registering with <c>epmd</c>, you need to first create a listen socket
       and bind it to a port. Then:</p>
     <code type="none"><![CDATA[
 int pub;
 
 pub = erl_publish(port);    ]]></code>
-    <p><c><![CDATA[pub]]></c> is a file descriptor now connected to <c><![CDATA[epmd]]></c>. <c><![CDATA[Epmd]]></c>
+    <p><c>pub</c> is a file descriptor now connected to <c>epmd</c>. <c>Epmd</c>
       monitors the other end of the connection, and if it detects that the
       connection has been closed, the node will be unregistered. So, if you
       explicitly close the descriptor or if your node fails, it will be
-      unregistered from <c><![CDATA[epmd]]></c>.</p>
+      unregistered from <c>epmd</c>.</p>
     <p>Be aware that on some systems (such as VxWorks), a failed node will
       not be detected by this mechanism since the operating system does not
       automatically close descriptors that were left open when the node
-      failed. If a node has failed in this way, <c><![CDATA[epmd]]></c> will prevent you from
+      failed. If a node has failed in this way, <c>epmd</c> will prevent you from
       registering a new node with the old name, since it thinks that the old
       name is still in use. In this case, you must unregister the name
       explicitly:</p>
     <code type="none"><![CDATA[
 erl_unpublish(node);    ]]></code>
-    <p>This will cause <c><![CDATA[epmd]]></c> to close the connection from the far end. Note
+    <p>This will cause <c>epmd</c> to close the connection from the far end. Note
       that if the name was in fact still in use by a node, the results of
       this operation are unpredictable. Also, doing this does not cause the
       local end of the connection to close, so resources may be consumed.</p>
@@ -321,8 +321,8 @@ erl_unpublish(node);    ]]></code>
     <title>Sending and Receiving Erlang Messages</title>
     <p>Use one of the following two functions to send messages:</p>
     <list type="bulleted">
-      <item><c><![CDATA[erl_send()]]></c></item>
-      <item><c><![CDATA[erl_reg_send()]]></c></item>
+      <item><c>erl_send()</c></item>
+      <item><c>erl_reg_send()</c></item>
     </list>
     <p>As in Erlang, it is possible to send messages to a 
       <em>Pid</em> or to a registered name. It is easier to send a
@@ -330,17 +330,17 @@ erl_unpublish(node);    ]]></code>
       a suitable <em>Pid</em>.</p>
     <p>Use one of the following two functions to receive messages:</p>
     <list type="bulleted">
-      <item><c><![CDATA[erl_receive()]]></c></item>
-      <item><c><![CDATA[erl_receive_msg()]]></c></item>
+      <item><c>erl_receive()</c></item>
+      <item><c>erl_receive_msg()</c></item>
     </list>
-    <p><c><![CDATA[erl_receive()]]></c> receives the message into a buffer, while
-      <c><![CDATA[erl_receive_msg()]]></c> decodes the message into an Erlang term. </p>
+    <p><c>erl_receive()</c> receives the message into a buffer, while
+      <c>erl_receive_msg()</c> decodes the message into an Erlang term. </p>
 
     <section>
       <title>Example of Sending Messages</title>
-      <p>In the following example, <c><![CDATA[{Pid, hello_world}]]></c> is
-        sent to a registered process <c><![CDATA[my_server]]></c>. The message is encoded
-        by <c><![CDATA[erl_send()]]></c>:</p>
+      <p>In the following example, <c>{Pid, hello_world}</c> is
+        sent to a registered process <c>my_server</c>. The message is encoded
+        by <c>erl_send()</c>:</p>
       <code type="none"><![CDATA[
 extern const char *erl_thisnodename(void);
 extern short erl_thiscreation(void);
@@ -355,15 +355,15 @@ emsg   = erl_mk_tuple(arr, 2);
 erl_reg_send(sockfd, "my_server", emsg);
 erl_free_term(emsg);      ]]></code>
       <p>The first element of the tuple that is sent is your own
-        <em>Pid</em>. This enables <c><![CDATA[my_server]]></c> to reply. Refer to the
-        Reference Manual, the <c><![CDATA[erl_connect]]></c> module for more information
+        <em>Pid</em>. This enables <c>my_server</c> to reply. Refer to the
+        Reference Manual, the <c>erl_connect</c> module for more information
         about send primitives.</p>
     </section>
 
     <section>
       <title>Example of Receiving Messages</title>
-      <p>In this example <c><![CDATA[{Pid, Something}]]></c> is received. The
-        received Pid is then used to return <c><![CDATA[{goodbye,Pid}]]></c></p>
+      <p>In this example <c>{Pid, Something}</c> is received. The
+        received Pid is then used to return <c>{goodbye,Pid}</c></p>
       <code type="none"><![CDATA[
 ETERM *arr[2], *answer;
 int sockfd,rc;
@@ -383,18 +383,18 @@ if ((rc = erl_receive_msg(sockfd , buf, BUFSIZE, &emsg)) == ERL_MSG) {
       <p>In order to provide robustness, a distributed Erlang node
         occasionally polls all its connected neighbours in an attempt to
         detect failed nodes or communication links. A node which receives such
-        a message is expected to respond immediately with an <c><![CDATA[ERL_TICK]]></c> message.
-        This is done automatically by <c><![CDATA[erl_receive()]]></c>, however when this
-        has occurred <c><![CDATA[erl_receive]]></c> returns <c><![CDATA[ERL_TICK]]></c> to the caller
-        without storing a message into the <c><![CDATA[ErlMessage]]></c> structure.</p>
+        a message is expected to respond immediately with an <c>ERL_TICK</c> message.
+        This is done automatically by <c>erl_receive()</c>, however when this
+        has occurred <c>erl_receive</c> returns <c>ERL_TICK</c> to the caller
+        without storing a message into the <c>ErlMessage</c> structure.</p>
       <p>When a message has been received, it is the caller's responsibility
-        to free the received message <c><![CDATA[emsg.msg]]></c> as well as <c><![CDATA[emsg.to]]></c>
-        or <c><![CDATA[emsg.from]]></c>, depending on the type of message received.</p>
+        to free the received message <c>emsg.msg</c> as well as <c>emsg.to</c>
+        or <c>emsg.from</c>, depending on the type of message received.</p>
       <p>Refer to the Reference Manual for additional information about the
         following modules:</p>
       <list type="bulleted">
-        <item><c><![CDATA[erl_connect]]></c></item>
-        <item><c><![CDATA[erl_eterm]]></c>.</item>
+        <item><c>erl_connect</c></item>
+        <item><c>erl_eterm</c>.</item>
       </list>
     </section>
   </section>
@@ -421,12 +421,12 @@ if (!erl_match(ep, reply))
 ");
 erl_free_term(ep);
 erl_free_term(reply);    ]]></code>
-    <p><c><![CDATA[c:c/1]]></c> is called to compile the specified module on the
-      remote node. <c><![CDATA[erl_match()]]></c> checks that the compilation was
-      successful by testing for the expected <c><![CDATA[ok]]></c>.</p>
-    <p>Refer to the Reference Manual, the <c><![CDATA[erl_connect]]></c> module for
-      more information about <c><![CDATA[erl_rpc()]]></c>, and its companions
-      <c><![CDATA[erl_rpc_to()]]></c> and <c><![CDATA[erl_rpc_from()]]></c>.</p>
+    <p><c>c:c/1</c> is called to compile the specified module on the
+      remote node. <c>erl_match()</c> checks that the compilation was
+      successful by testing for the expected <c>ok</c>.</p>
+    <p>Refer to the Reference Manual, the <c>erl_connect</c> module for
+      more information about <c>erl_rpc()</c>, and its companions
+      <c>erl_rpc_to()</c> and <c>erl_rpc_from()</c>.</p>
   </section>
 
   <section>
@@ -454,14 +454,14 @@ if (names)
 ",names[i]);
 
 free(names);    ]]></code>
-    <p><c><![CDATA[erl_global_names()]]></c> allocates and returns a buffer containing
-      all the names known to global. <c><![CDATA[count]]></c> will be initialized to
+    <p><c>erl_global_names()</c> allocates and returns a buffer containing
+      all the names known to global. <c>count</c> will be initialized to
       indicate how many names are in the array. The array of strings in
       names is terminated by a NULL pointer, so it is not necessary to use
-      <c><![CDATA[count]]></c> to determine when the last name is reached.</p>
+      <c>count</c> to determine when the last name is reached.</p>
     <p>It is the caller's responsibility to free the array.
-      <c><![CDATA[erl_global_names()]]></c> allocates the array and all of the strings
-      using a single call to <c><![CDATA[malloc()]]></c>, so <c><![CDATA[free(names)]]></c> is all
+      <c>erl_global_names()</c> allocates the array and all of the strings
+      using a single call to <c>malloc()</c>, so <c>free(names)</c> is all
       that is necessary.</p>
     <p>To look up one of the names:</p>
     <code type="none"><![CDATA[
@@ -469,13 +469,13 @@ ETERM *pid;
 char node[256];
 
 pid = erl_global_whereis(fd,"schedule",node);    ]]></code>
-    <p>If <c><![CDATA["schedule"]]></c> is known to global, an Erlang pid is returned
+    <p>If <c>"schedule"</c> is known to global, an Erlang pid is returned
       that can be used to send messages to the schedule service.
-      Additionally, <c><![CDATA[node]]></c> will be initialized to contain the name of
+      Additionally, <c>node</c> will be initialized to contain the name of
       the node where the service is registered, so that you can make a
-      connection to it by simply passing the variable to <c><![CDATA[erl_connect()]]></c>.</p>
+      connection to it by simply passing the variable to <c>erl_connect()</c>.</p>
     <p>Before registering a name, you should already have registered your
-      port number with <c><![CDATA[epmd]]></c>. This is not strictly necessary, but if you
+      port number with <c>epmd</c>. This is not strictly necessary, but if you
       neglect to do so, then other nodes wishing to communicate with your
       service will be unable to find or connect to your process.</p>
     <p>Create a pid that Erlang processes can use to communicate with your
@@ -485,9 +485,9 @@ ETERM *pid;
 
 pid = erl_mk_pid(thisnode,14,0,0);
 erl_global_register(fd,servicename,pid);    ]]></code>
-    <p>After registering the name, you should use <c><![CDATA[erl_accept()]]></c> to wait for
+    <p>After registering the name, you should use <c>erl_accept()</c> to wait for
       incoming connections.</p>
-    <p>Do not forget to free <c><![CDATA[pid]]></c> later with <c><![CDATA[erl_free_term()]]></c>!</p>
+    <p>Do not forget to free <c>pid</c> later with <c>erl_free_term()</c>!</p>
     <p>To unregister a name:</p>
     <code type="none"><![CDATA[
 erl_global_unregister(fd,servicename);    ]]></code>
@@ -570,12 +570,12 @@ ei_reg_close(reg);    ]]></code>
       <title>Backing Up the Registry to Mnesia</title>
       <p>The contents of a registry can be backed up to Mnesia on a "nearby"
         Erlang node. You need to provide an open connection to the Erlang node
-        (see <c><![CDATA[erl_connect()]]></c>). Also, Mnesia 3.0 or later must be running
+        (see <c>erl_connect()</c>). Also, Mnesia 3.0 or later must be running
         on the Erlang node before the backup is initiated:</p>
       <code type="none"><![CDATA[
 ei_reg_dump(fd, reg, "mtab", dumpflags);      ]]></code>
       <p>The example above will backup the contents of the registry to the
-        specified Mnesia table <c><![CDATA["mtab"]]></c>. Once a registry has been backed
+        specified Mnesia table <c>"mtab"</c>. Once a registry has been backed
         up to Mnesia in this manner, additional backups will only affect
         objects that have been modified since the most recent backup, i.e.
         objects that have been created, changed or deleted. The backup
@@ -584,7 +584,7 @@ ei_reg_dump(fd, reg, "mtab", dumpflags);      ]]></code>
       <p>In the same manner, a registry can be restored from a Mnesia table:</p>
       <code type="none"><![CDATA[
 ei_reg_restore(fd, reg, "mtab");      ]]></code>
-      <p>This will read the entire contents of <c><![CDATA["mtab"]]></c> into the specified
+      <p>This will read the entire contents of <c>"mtab"</c> into the specified
         registry. After the restore, all of the objects in the registry will
         be marked as unmodified, so a subsequent backup will only affect
         objects that you have modified since the restore.</p>
@@ -600,8 +600,8 @@ ei_reg_restore(fd, reg, "mtab");      ]]></code>
       <p>When string or binary objects are stored in the registry it is
         important that a number of simple guidelines are followed. </p>
       <p>Most importantly, the object must have been created with a single call
-        to <c><![CDATA[malloc()]]></c> (or similar), so that it can later be removed by a
-        single call to <c><![CDATA[free()]]></c>. Objects will be freed by the registry
+        to <c>malloc()</c> (or similar), so that it can later be removed by a
+        single call to <c>free()</c>. Objects will be freed by the registry
         when it is closed, or when you assign a new value to an object that
         previously contained a string or binary.</p>
       <p>You should also be aware that if you store binary objects that are
@@ -618,8 +618,8 @@ ei_reg_restore(fd, reg, "mtab");      ]]></code>
         you make, possibly causing it to be missed the next time you make a
         Mnesia backup of the registry contents. This can be avoided if you
         mark the object as dirty after any such changes with
-        <c><![CDATA[ei_reg_markdirty()]]></c>, or pass appropriate flags to
-        <c><![CDATA[ei_reg_dump()]]></c>.</p>
+        <c>ei_reg_markdirty()</c>, or pass appropriate flags to
+        <c>ei_reg_dump()</c>.</p>
     </section>
   </section>
 </chapter>
diff --git a/lib/erl_interface/doc/src/erl_malloc.xml b/lib/erl_interface/doc/src/erl_malloc.xml
index e08924ec51..c0eebc29e9 100644
--- a/lib/erl_interface/doc/src/erl_malloc.xml
+++ b/lib/erl_interface/doc/src/erl_malloc.xml
@@ -47,8 +47,8 @@
         <v>unsigned char etype;</v>
       </type>
       <desc>
-        <p>Allocates an <c><![CDATA[(ETERM)]]></c> structure.</p>
-        <p>Specify <c><![CDATA[etype]]></c> as one of the following
+        <p>Allocates an <c>(ETERM)</c> structure.</p>
+        <p>Specify <c>etype</c> as one of the following
           constants:</p>
         <list type="bulleted">
           <item><c>ERL_INTEGER</c>
@@ -80,9 +80,9 @@
           <item><c>ERL_U_SMALL_BIG</c> (bignum)
           </item>
         </list>
-        <p><c><![CDATA[ERL_SMALL_BIG]]></c> and
-          <c><![CDATA[ERL_U_SMALL_BIG]]></c> are for
-          creating Erlang <c><![CDATA[bignums]]></c>, which can contain integers
+        <p><c>ERL_SMALL_BIG</c> and
+          <c>ERL_U_SMALL_BIG</c> are for
+          creating Erlang <c>bignums</c>, which can contain integers
           of any size. The size of an integer in Erlang is machine-dependent,
           but any integer &gt; 2^28 requires a bignum.</p>
       </desc>
@@ -93,8 +93,8 @@
       <fsummary>Clear the ETERM freelist.</fsummary>
       <desc>
         <p>Clears the freelist, where blocks are placed when they are
-          released by <c><![CDATA[erl_free_term()]]></c> and
-          <c><![CDATA[erl_free_compound()]]></c>.</p>
+          released by <c>erl_free_term()</c> and
+          <c>erl_free_compound()</c>.</p>
       </desc>
     </func>
 
@@ -107,20 +107,20 @@
       </type>
       <desc>
         <p>Reports term allocation statistics.</p>
-        <p><c><![CDATA[allocated]]></c> and <c><![CDATA[freed]]></c> are
+        <p><c>allocated</c> and <c>freed</c> are
           initialized to
           contain information about the fix-allocator used to allocate
           <c>ETERM</c> components.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[allocated]]></c> is the number of blocks currently
+            <p><c>allocated</c> is the number of blocks currently
               allocated to <c>ETERM</c> objects.</p>
           </item>
           <item>
-            <p><c><![CDATA[freed]]></c> is the length of the freelist, where
+            <p><c>freed</c> is the length of the freelist, where
               blocks are placed when they are
-              released by <c><![CDATA[erl_free_term()]]></c> and
-              <c><![CDATA[erl_free_compound()]]></c>.</p>
+              released by <c>erl_free_term()</c> and
+              <c>erl_free_compound()</c>.</p>
           </item>
         </list>
       </desc>
@@ -134,7 +134,7 @@
       </type>
       <desc>
         <p>Calls the standard
-          <c><![CDATA[free()]]></c> function.</p>
+          <c>free()</c> function.</p>
       </desc>
     </func>
 
@@ -148,8 +148,8 @@
       <desc>
         <p>Frees an array of Erlang terms.</p>
         <list type="bulleted">
-          <item><c><![CDATA[array]]></c> is an array of ETERM* objects.</item>
-          <item><c><![CDATA[size]]></c> is the number of terms in the array.
+          <item><c>array</c> is an array of ETERM* objects.</item>
+          <item><c>size</c> is the number of terms in the array.
           </item>
         </list>
       </desc>
@@ -164,12 +164,12 @@
       <desc>
         <p>Normally it is the programmer's responsibility to free each
           Erlang term that has been returned from any of the
-          <c><![CDATA[Erl_Interface]]></c> functions. However, as many of the
+          <c>Erl_Interface</c> functions. However, as many of the
           functions that build new Erlang terms in fact share objects
           with other existing terms, it can be difficult for the
           programmer to maintain pointers to all such terms to
           free them individually.</p>
-        <p><c><![CDATA[erl_free_compound()]]></c> recursively frees all of the
+        <p><c>erl_free_compound()</c> recursively frees all of the
           subterms associated with a specified Erlang term, regardless of
           whether we are still holding pointers to the subterms.</p>
         <p>For an example, see section
@@ -197,7 +197,7 @@
       </type>
       <desc>
         <p>Calls the standard
-          <c><![CDATA[malloc()]]></c> function.</p>
+          <c>malloc()</c> function.</p>
       </desc>
     </func>
   </funcs>
diff --git a/lib/erl_interface/doc/src/erl_marshal.xml b/lib/erl_interface/doc/src/erl_marshal.xml
index b333bc9993..2ad658f78b 100644
--- a/lib/erl_interface/doc/src/erl_marshal.xml
+++ b/lib/erl_interface/doc/src/erl_marshal.xml
@@ -50,9 +50,9 @@
       <desc>
         <p>Compares two encoded terms.</p>
         <list type="bulleted">
-          <item><c><![CDATA[bufp1]]></c> is a buffer containing an encoded
+          <item><c>bufp1</c> is a buffer containing an encoded
             Erlang term term1.</item>
-          <item><c><![CDATA[bufp2]]></c> is a buffer containing an encoded
+          <item><c>bufp2</c> is a buffer containing an encoded
             Erlang term term2.</item>
         </list>
         <p>Returns <c>0</c> if the terms are equal, <c>-1</c> if
@@ -70,31 +70,31 @@
         <v>unsigned char **bufpp;</v>
       </type>
       <desc>
-        <p><c><![CDATA[erl_decode()]]></c> and
-          <c><![CDATA[erl_decode_buf()]]></c> decode
+        <p><c>erl_decode()</c> and
+          <c>erl_decode_buf()</c> decode
           the contents of a buffer and return the corresponding
-          Erlang term. <c><![CDATA[erl_decode_buf()]]></c> provides a simple
+          Erlang term. <c>erl_decode_buf()</c> provides a simple
           mechanism for dealing with several encoded terms stored
           consecutively in the buffer.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[bufp]]></c> is a pointer to a buffer containing one
+            <p><c>bufp</c> is a pointer to a buffer containing one
               or more encoded Erlang terms.</p>
           </item>
           <item>
-            <p><c><![CDATA[bufpp]]></c> is the address of a buffer pointer. The
+            <p><c>bufpp</c> is the address of a buffer pointer. The
               buffer contains one or more consecutively encoded Erlang terms.
               Following a successful call to
-              <c><![CDATA[erl_decode_buf()]]></c>, <c><![CDATA[bufpp]]></c> is
+              <c>erl_decode_buf()</c>, <c>bufpp</c> is
               updated so that it points to the next encoded term.</p>
           </item>
         </list>
-        <p><c><![CDATA[erl_decode()]]></c> returns an Erlang term
-          corresponding to the contents of <c><![CDATA[bufp]]></c> on success,
-          otherwise <c>NULL</c>. <c><![CDATA[erl_decode_buf()]]></c>
+        <p><c>erl_decode()</c> returns an Erlang term
+          corresponding to the contents of <c>bufp</c> on success,
+          otherwise <c>NULL</c>. <c>erl_decode_buf()</c>
           returns an Erlang
           term corresponding to the first of the consecutive terms in
-          <c><![CDATA[bufpp]]></c> and moves <c><![CDATA[bufpp]]></c> forward
+          <c>bufpp</c> and moves <c>bufpp</c> forward
           to point to the
           next term in the buffer. On failure, each of the functions
           return <c>NULL</c>.</p>
@@ -111,10 +111,10 @@
         <v>unsigned char **bufpp;</v>
       </type>
       <desc>
-        <p><c><![CDATA[erl_encode()]]></c> and
-          <c><![CDATA[erl_encode_buf()]]></c> encode
+        <p><c>erl_encode()</c> and
+          <c>erl_encode_buf()</c> encode
           Erlang terms into external format for storage or transmission.
-          <c><![CDATA[erl_encode_buf()]]></c> provides a simple mechanism for
+          <c>erl_encode_buf()</c> provides a simple mechanism for
           encoding several terms consecutively in the same buffer.</p>
         <list type="bulleted">
           <item>
@@ -128,7 +128,7 @@
             <p><c>bufpp</c> is a pointer to a pointer to a buffer
               containing one or more consecutively encoded Erlang terms.
               Following a successful call to
-              <c><![CDATA[erl_encode_buf()]]></c>, <c>bufpp</c> is updated so
+              <c>erl_encode_buf()</c>, <c>bufpp</c> is updated so
               that it points to the
               position for the next encoded term.</p>
           </item>
@@ -139,36 +139,36 @@
           the caller's responsibility to ensure that the buffer is
           large enough to hold the encoded terms. You can either use a
           static buffer that is large enough to hold the terms you expect
-          to need in your program, or use <c><![CDATA[erl_term_len()]]></c>
+          to need in your program, or use <c>erl_term_len()</c>
           to determine the exact requirements for a given term.</p>
         <p>The following can help you estimate the buffer
           requirements for a term. Notice that this information is
           implementation-specific, and can change in future versions.
-          If you are unsure, use <c><![CDATA[erl_term_len()]]></c>.</p>
+          If you are unsure, use <c>erl_term_len()</c>.</p>
         <p>Erlang terms are encoded with a 1 byte tag that
           identifies the type of object, a 2- or 4-byte length field,
           and then the data itself. Specifically:</p>
         <taglist>
-          <tag><c><![CDATA[Tuples]]></c></tag>
+          <tag><c>Tuples</c></tag>
           <item>Need 5 bytes, plus the space for each element.</item>
-          <tag><c><![CDATA[Lists]]></c></tag>
+          <tag><c>Lists</c></tag>
           <item>Need 5 bytes, plus the space for each element, and 1
             more byte for the empty list at the end.</item>
-          <tag><c><![CDATA[Strings and atoms]]></c></tag>
+          <tag><c>Strings and atoms</c></tag>
           <item>Need 3 bytes, plus 1 byte for each character (the
             terminating 0 is not encoded). Really long strings (more
             than 64k characters) are encoded as lists. Atoms cannot
             contain more than 256 characters.</item>
-          <tag><c><![CDATA[Integers]]></c></tag>
+          <tag><c>Integers</c></tag>
           <item>Need 5 bytes.</item>
-          <tag><c><![CDATA[Characters]]></c></tag>
+          <tag><c>Characters</c></tag>
           <item>(Integers &lt; 256) need 2 bytes.</item>
-          <tag><c><![CDATA[Floating point numbers]]></c></tag>
+          <tag><c>Floating point numbers</c></tag>
           <item>Need 32 bytes.</item>
-          <tag><c><![CDATA[Pids]]></c></tag>
+          <tag><c>Pids</c></tag>
           <item>Need 10 bytes, plus the space for the node name, which
             is an atom.</item>
-          <tag><c><![CDATA[Ports and Refs]]></c></tag>
+          <tag><c>Ports and Refs</c></tag>
           <item>Need 6 bytes, plus the space for the node name, which
             is an atom.</item>
         </taglist>
@@ -198,7 +198,7 @@
       <desc>
         <p>Identifies and returns the type of Erlang term encoded
           in a buffer. It skips a trailing <em>magic</em> identifier.</p>
-        <p>Returns <c><![CDATA[0]]></c> if the type cannot be determined or
+        <p>Returns <c>0</c> if the type cannot be determined or
           one of:</p>
         <list type="bulleted">
           <item><c>ERL_INTEGER</c>
@@ -238,15 +238,15 @@
         <p>This function is used for stepping over one or more
           encoded terms in a buffer, to directly access later term.</p>
         <list type="bulleted">
-          <item><c><![CDATA[bufp]]></c> is a pointer to a buffer containing one
+          <item><c>bufp</c> is a pointer to a buffer containing one
             or more encoded Erlang terms.</item>
-          <item><c><![CDATA[pos]]></c> indicates how many terms to step over in
+          <item><c>pos</c> indicates how many terms to step over in
             the buffer.</item>
         </list>
         <p>Returns a pointer to a subterm that can be
-          used in a later call to <c><![CDATA[erl_decode()]]></c> to retrieve
+          used in a later call to <c>erl_decode()</c> to retrieve
           the term at that position. If there is no term, or
-          <c><![CDATA[pos]]></c> would exceed the size of the terms in the
+          <c>pos</c> would exceed the size of the terms in the
           buffer, <c>NULL</c> is returned.</p>
       </desc>
     </func>
@@ -259,8 +259,8 @@
       </type>
       <desc>
         <p>Determines the buffer space that would be
-          needed by <c><![CDATA[t]]></c> if it were encoded into Erlang external
-          format by <c><![CDATA[erl_encode()]]></c>.</p>
+          needed by <c>t</c> if it were encoded into Erlang external
+          format by <c>erl_encode()</c>.</p>
         <p>Returns the size in bytes.</p>
       </desc>
     </func>
diff --git a/lib/erl_interface/doc/src/ref_man_ei.xml b/lib/erl_interface/doc/src/ref_man_ei.xml
index d24828c394..92ff9ed328 100644
--- a/lib/erl_interface/doc/src/ref_man_ei.xml
+++ b/lib/erl_interface/doc/src/ref_man_ei.xml
@@ -11,7 +11,7 @@
       Licensed under the Apache License, Version 2.0 (the "License");
       you may not use this file except in compliance with the License.
       You may obtain a copy of the License at
- 
+
           http://www.apache.org/licenses/LICENSE-2.0
 
       Unless required by applicable law or agreed to in writing, software
@@ -19,7 +19,7 @@
       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
       See the License for the specific language governing permissions and
       limitations under the License.
-    
+
     </legalnotice>
 
     <title>EI Library Reference</title>
@@ -30,12 +30,12 @@
     <file>ref_man_ei.xml</file>
   </header>
   <description>
-    <p>The <c><![CDATA[ei]]></c> library is a <c><![CDATA[C]]></c> interface library for
-      communication with <c><![CDATA[Erlang]]></c>.</p>
+    <p>The <c>ei</c> library is a <c>C</c> interface library for
+      communication with <c>Erlang</c>.</p>
     <note>
-      <p>By default, the <c><![CDATA[ei]]></c> library is only guaranteed
+      <p>By default, the <c>ei</c> library is only guaranteed
         to be compatible with other Erlang/OTP components from the same
-        release as the <c><![CDATA[ei]]></c> library itself. See the documentation of the
+        release as the <c>ei</c> library itself. See the documentation of the
         <seealso marker="ei#ei_set_compat_rel">ei_set_compat_rel()</seealso>
         function on how to communicate with Erlang/OTP components from earlier
         releases.</p>
@@ -45,4 +45,3 @@
   <xi:include href="ei_connect.xml"/>
   <xi:include href="registry.xml"/>
 </application>
-
diff --git a/lib/erl_interface/doc/src/registry.xml b/lib/erl_interface/doc/src/registry.xml
index 00b8f770de..6d70fb3475 100644
--- a/lib/erl_interface/doc/src/registry.xml
+++ b/lib/erl_interface/doc/src/registry.xml
@@ -51,9 +51,9 @@
       </type>
       <desc>
         <p>A registry that has previously been created with
-          <c><![CDATA[ei_reg_open()]]></c> is closed, and all the objects it
+          <c>ei_reg_open()</c> is closed, and all the objects it
           contains are freed.</p>
-        <p><c><![CDATA[reg]]></c> is the registry to close.</p>
+        <p><c>reg</c> is the registry to close.</p>
         <p>Returns <c>0</c>.</p>
       </desc>
     </func>
@@ -73,12 +73,12 @@
           well. If another object is later created with the same key, the
           object will be reused. </p>
         <p>The object is removed from the registry after a call to
-          <c><![CDATA[ei_reg_dump()]]></c> or <c><![CDATA[ei_reg_purge()]]></c>.
+          <c>ei_reg_dump()</c> or <c>ei_reg_purge()</c>.
         </p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry containing
-            <c><![CDATA[key]]></c>.</item>
-          <item><c><![CDATA[key]]></c> is the object to remove.</item>
+          <item><c>reg</c> is the registry containing
+            <c>key</c>.</item>
+          <item><c>key</c> is the object to remove.</item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
       </desc>
@@ -99,17 +99,17 @@
           If any errors are encountered while backing up
           the data, the entire operation is aborted.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open connection to Erlang.
+          <item><c>fd</c> is an open connection to Erlang.
             <c>Mnesia</c> 3.0 or later must be running on the Erlang node.
           </item>
-          <item><c><![CDATA[reg]]></c> is the registry to back up.</item>
-          <item><c><![CDATA[mntab]]></c> is the name of the <c>Mnesia</c> table
+          <item><c>reg</c> is the registry to back up.</item>
+          <item><c>mntab</c> is the name of the <c>Mnesia</c> table
             where the backed up data is to be placed. If the table does not
             exist, it is created automatically using configurable defaults.
             For information about configuring this behavior, see
             <seealso marker="mnesia:mnesia"><c>Mnesia</c></seealso>.</item>
         </list>
-        <p>If <c><![CDATA[flags]]></c> is <c>0</c>, the backup includes only
+        <p>If <c>flags</c> is <c>0</c>, the backup includes only
           those objects that have been created, modified, or deleted since the
           last backup or restore (that is, an incremental backup). After the
           backup, any objects that were marked dirty are now clean, and any
@@ -118,7 +118,7 @@
           backup to be done, and <c>EI_NOPURGE</c> causes the deleted objects
           to be left in the registry afterwards. These can be bitwise OR'ed
           together if both behaviors are desired. If <c>EI_NOPURGE</c> was
-          specified, <c><![CDATA[ei_reg_purge()]]></c> can be used to
+          specified, <c>ei_reg_purge()</c> can be used to
           explicitly remove the deleted items from the registry later.</p>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
       </desc>
@@ -132,21 +132,21 @@
         <v>const char *key;</v>
       </type>
       <desc>
-        <p>Gets the value associated with <c><![CDATA[key]]></c> in the
+        <p>Gets the value associated with <c>key</c> in the
           registry. The value must be a floating point type.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object will be
+          <item><c>reg</c> is the registry where the object will be
             looked up.</item>
-          <item><c><![CDATA[key]]></c> is the name of the object to look up.
+          <item><c>key</c> is the name of the object to look up.
           </item>
         </list>
         <p>On success, the function returns the value associated with
-          <c><![CDATA[key]]></c>.
+          <c>key</c>.
           If the object is not found or if it is not a floating point
           object, <c>-1.0</c> is returned. To avoid problems with in-band error
           reporting (that is, if you cannot distinguish between <c>-1.0</c> and
           a valid result), use the more general function
-          <c><![CDATA[ei_reg_getval()]]></c> instead.</p>
+          <c>ei_reg_getval()</c> instead.</p>
       </desc>
     </func>
 
@@ -158,21 +158,21 @@
         <v>const char *key;</v>
       </type>
       <desc>
-        <p>Gets the value associated with <c><![CDATA[key]]></c> in the
+        <p>Gets the value associated with <c>key</c> in the
           registry. The value must be an integer.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object will be
+          <item><c>reg</c> is the registry where the object will be
             looked up.</item>
-          <item><c><![CDATA[key]]></c> is the name of the object to look up.
+          <item><c>key</c> is the name of the object to look up.
           </item>
         </list>
         <p>On success, the function returns the value associated with
-          <c><![CDATA[key]]></c>.
+          <c>key</c>.
           If the object is not found or if it is not an integer
           object, <c>-1</c> is returned. To avoid problems with in-band error
           reporting (that is, if you cannot distinguish between <c>-1</c> and a
           valid result), use the more general function
-          <c><![CDATA[ei_reg_getval()]]></c> instead.</p>
+          <c>ei_reg_getval()</c> instead.</p>
       </desc>
     </func>
 
@@ -185,24 +185,24 @@
         <v>int size;</v>
       </type>
       <desc>
-        <p>Gets the value associated with <c><![CDATA[key]]></c> in the
+        <p>Gets the value associated with <c>key</c> in the
           registry. The value must be a binary (pointer) type.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object will be
+          <item><c>reg</c> is the registry where the object will be
             looked up.</item>
-          <item><c><![CDATA[key]]></c> is the name of the object to look up.
+          <item><c>key</c> is the name of the object to look up.
           </item>
-          <item><c><![CDATA[size]]></c> is initialized to contain the length in
+          <item><c>size</c> is initialized to contain the length in
             bytes of the object, if it is found.</item>
         </list>
         <p>On success, the function returns the value associated with
-          <c><![CDATA[key]]></c> and indicates its length in
-          <c><![CDATA[size]]></c>.
+          <c>key</c> and indicates its length in
+          <c>size</c>.
           If the object is not found or if it is not a binary object,
           <c>NULL</c> is returned. To avoid problems with in-band error
           reporting (that is, if you cannot distinguish between <c>NULL</c> and
           a valid result), use the more general function
-          <c><![CDATA[ei_reg_getval()]]></c> instead.</p>
+          <c>ei_reg_getval()</c> instead.</p>
       </desc>
     </func>
 
@@ -214,20 +214,20 @@
         <v>const char *key;</v>
       </type>
       <desc>
-        <p>Gets the value associated with <c><![CDATA[key]]></c> in the
+        <p>Gets the value associated with <c>key</c> in the
           registry. The value must be a string.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object will be
+          <item><c>reg</c> is the registry where the object will be
             looked up.</item>
-          <item><c><![CDATA[key]]></c> is the name of the object to look up.
+          <item><c>key</c> is the name of the object to look up.
           </item>
         </list>
         <p>On success, the function returns the value associated with
-          <c><![CDATA[key]]></c>. If the object is not found or if it is not a
+          <c>key</c>. If the object is not found or if it is not a
           string, <c>NULL</c> is returned. To avoid problems with in-band error
           reporting (that is, if you cannot distinguish between <c>NULL</c> and
           a valid result), use the more general function
-          <c><![CDATA[ei_reg_getval()]]></c> instead.</p>
+          <c>ei_reg_getval()</c> instead.</p>
       </desc>
     </func>
 
@@ -245,32 +245,32 @@
           object from the registry.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[reg]]></c> is the registry where the object will be
+            <p><c>reg</c> is the registry where the object will be
               looked up.</p>
           </item>
           <item>
-            <p><c><![CDATA[key]]></c> is the name of the object to look up.</p>
+            <p><c>key</c> is the name of the object to look up.</p>
           </item>
           <item>
-            <p><c><![CDATA[flags]]></c> indicates the type of object that you
-              are looking for. If <c><![CDATA[flags]]></c> is <c>0</c>, any
+            <p><c>flags</c> indicates the type of object that you
+              are looking for. If <c>flags</c> is <c>0</c>, any
               kind of object is returned.
-              If <c><![CDATA[flags]]></c> is <c>EI_INT</c>, <c>EI_FLT</c>,
+              If <c>flags</c> is <c>EI_INT</c>, <c>EI_FLT</c>,
               <c>EI_STR</c>, or <c>EI_BIN</c>, then only values of
               that kind are returned.</p>
-            <p>The buffer pointed to by <c><![CDATA[v]]></c>
+            <p>The buffer pointed to by <c>v</c>
               must be large enough to hold the return data, that is, it must be
-              a pointer to one of <c><![CDATA[int]]></c>,
-              <c><![CDATA[double]]></c>, <c><![CDATA[char*]]></c>, or
-              <c><![CDATA[void*]]></c>, respectively.</p>
-            <p>If <c><![CDATA[flags]]></c> is <c>EI_BIN</c>, a fifth argument
-              <c><![CDATA[int *size]]></c> is required, so that the size of the
+              a pointer to one of <c>int</c>,
+              <c>double</c>, <c>char*</c>, or
+              <c>void*</c>, respectively.</p>
+            <p>If <c>flags</c> is <c>EI_BIN</c>, a fifth argument
+              <c>int *size</c> is required, so that the size of the
               object can be returned.</p>
           </item>
         </list>
-        <p>On success, <c><![CDATA[v]]></c> (and <c><![CDATA[size]]></c> if the
+        <p>On success, <c>v</c> (and <c>size</c> if the
           object is binary) is initialized with the value associated
-          with <c><![CDATA[key]]></c>, and the function returns <c>EI_INT</c>,
+          with <c>key</c>, and the function returns <c>EI_INT</c>,
           <c>EI_FLT</c>, <c>EI_STR</c>, or <c>EI_BIN</c>, indicating the type
           of object. On failure, <c>-1</c> is returned and the
           arguments are not updated.</p>
@@ -295,9 +295,9 @@
           unmodified. This function allows you to make such modifications
           and then let the registry know about them.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry containing the object.
+          <item><c>reg</c> is the registry containing the object.
           </item>
-          <item><c><![CDATA[key]]></c> is the name of the object to mark.
+          <item><c>key</c> is the name of the object to mark.
           </item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
@@ -312,14 +312,14 @@
       </type>
       <desc>
         <p>Opens (creates) a registry, which initially is empty. To
-          close the registry later, use <c><![CDATA[ei_reg_close()]]></c>.</p>
-        <p><c><![CDATA[size]]></c> is the approximate number of objects you
+          close the registry later, use <c>ei_reg_close()</c>.</p>
+        <p><c>size</c> is the approximate number of objects you
           intend to store in the registry. As the registry uses a hash table
           with collision chaining, no absolute upper limit exists on the
           number of objects that can be stored in it. However, for reasons
           of efficiency, it is a good idea to choose a number that is
           appropriate for your needs. To change the size later, use
-          <c><![CDATA[ei_reg_resize()]]></c>. Notice that the number
+          <c>ei_reg_resize()</c>. Notice that the number
           you provide is increased to the nearest larger prime number.</p>
         <p>Returns an empty registry on success, otherwise <c>NULL</c>.</p>
       </desc>
@@ -333,13 +333,13 @@
       </type>
       <desc>
         <p>Removes all objects marked for deletion. When objects
-          are deleted with <c><![CDATA[ei_reg_delete()]]></c> they are not
+          are deleted with <c>ei_reg_delete()</c> they are not
           removed from the registry, only marked for later removal.
           On a later backup to <c>Mnesia</c>, the
           objects can also be removed from the <c>Mnesia</c> table. If you are
           not backing up to <c>Mnesia</c>, you may wish to remove the objects
           manually with this function.</p>
-        <p><c><![CDATA[reg]]></c> is a registry containing objects marked for
+        <p><c>reg</c> is a registry containing objects marked for
           deletion.</p>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
       </desc>
@@ -354,7 +354,7 @@
       </type>
       <desc>
         <p>Changes the size of a registry.</p>
-        <p><c><![CDATA[newsize]]></c> is the new size to make the registry. The
+        <p><c>newsize</c> is the new size to make the registry. The
           number is increased to the nearest larger prime number.</p>
         <p>On success, the registry is resized, all contents
           rehashed, and <c>0</c> is returned. On failure, the
@@ -373,17 +373,17 @@
       <desc>
         <p>The contents of a <c>Mnesia</c> table are read into the registry.</p>
         <list type="bulleted">
-          <item><c><![CDATA[fd]]></c> is an open connection to Erlang.
+          <item><c>fd</c> is an open connection to Erlang.
             <c>Mnesia</c> 3.0 or later must be running on the Erlang node.
           </item>
-          <item><c><![CDATA[reg]]></c> is the registry where the data is to be
+          <item><c>reg</c> is the registry where the data is to be
             placed.</item>
-          <item><c><![CDATA[mntab]]></c> is the name of the <c>Mnesia</c> table
+          <item><c>mntab</c> is the name of the <c>Mnesia</c> table
             to read data from.</item>
         </list>
         <p>Notice that only tables of a certain format can be
           restored, that is, those that have been created and backed up to
-          with <c><![CDATA[ei_reg_dump()]]></c>. If the registry was not empty
+          with <c>ei_reg_dump()</c>. If the registry was not empty
           before the operation, the contents of the table are added to the
           contents of the registry. If the table contains objects with the
           same keys as those already in the registry, the registry objects
@@ -407,16 +407,16 @@
         <v>double f;</v>
       </type>
       <desc>
-        <p>Creates a key-value pair with the specified <c><![CDATA[key]]></c>
-          and floating point value <c><![CDATA[f]]></c>. If an object already
-          exists with the same <c><![CDATA[key]]></c>, the new value replaces
+        <p>Creates a key-value pair with the specified <c>key</c>
+          and floating point value <c>f</c>. If an object already
+          exists with the same <c>key</c>, the new value replaces
           the old one. If the previous value was a binary or string, it is
-          freed with <c><![CDATA[free()]]></c>.</p>
+          freed with <c>free()</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object is to be
+          <item><c>reg</c> is the registry where the object is to be
             placed.</item>
-          <item><c><![CDATA[key]]></c> is the object name.</item>
-          <item><c><![CDATA[f]]></c> is the floating point value to assign.
+          <item><c>key</c> is the object name.</item>
+          <item><c>f</c> is the floating point value to assign.
           </item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
@@ -432,16 +432,16 @@
         <v>int i;</v>
       </type>
       <desc>
-        <p>Creates a key-value pair with the specified <c><![CDATA[key]]></c>
-          and integer value <c><![CDATA[i]]></c>. If an object already exists
-          with the same <c><![CDATA[key]]></c>, the new value replaces the old
+        <p>Creates a key-value pair with the specified <c>key</c>
+          and integer value <c>i</c>. If an object already exists
+          with the same <c>key</c>, the new value replaces the old
           one. If the previous value was a binary or string, it is freed with
-          <c><![CDATA[free()]]></c>.</p>
+          <c>free()</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object is to be
+          <item><c>reg</c> is the registry where the object is to be
             placed.</item>
-          <item><c><![CDATA[key]]></c> is the object name.</item>
-          <item><c><![CDATA[i]]></c> is the integer value to assign.</item>
+          <item><c>key</c> is the object name.</item>
+          <item><c>i</c> is the integer value to assign.</item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
       </desc>
@@ -457,21 +457,21 @@
         <v>int size;</v>
       </type>
       <desc>
-        <p>Creates a key-value pair with the specified <c><![CDATA[key]]></c>
-          whose "value" is the binary object pointed to by <c><![CDATA[p]]></c>.
-          If an object already exists with the same <c><![CDATA[key]]></c>,
+        <p>Creates a key-value pair with the specified <c>key</c>
+          whose "value" is the binary object pointed to by <c>p</c>.
+          If an object already exists with the same <c>key</c>,
           the new value replaces the old one. If the previous value was a
-          binary or string, it is freed with <c><![CDATA[free()]]></c>.</p>
+          binary or string, it is freed with <c>free()</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object is to be
+          <item><c>reg</c> is the registry where the object is to be
             placed.</item>
-          <item><c><![CDATA[key]]></c> is the object name.</item>
-          <item><c><![CDATA[p]]></c> is a pointer to the binary object. The
+          <item><c>key</c> is the object name.</item>
+          <item><c>p</c> is a pointer to the binary object. The
             object itself must have been created through a single call to
-            <c><![CDATA[malloc()]]></c> or a similar function, so that the
+            <c>malloc()</c> or a similar function, so that the
             registry can later delete it if necessary by calling
-            <c><![CDATA[free()]]></c>.</item>
-          <item><c><![CDATA[size]]></c> is the length in bytes of the binary
+            <c>free()</c>.</item>
+          <item><c>size</c> is the length in bytes of the binary
             object.</item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
@@ -487,20 +487,20 @@
         <v>const char *s;</v>
       </type>
       <desc>
-        <p>Creates a key-value pair with the specified <c><![CDATA[key]]></c>
-          whose "value" is the specified string <c><![CDATA[s]]></c>. If an
-          object already exists with the same <c><![CDATA[key]]></c>, the new
+        <p>Creates a key-value pair with the specified <c>key</c>
+          whose "value" is the specified string <c>s</c>. If an
+          object already exists with the same <c>key</c>, the new
           value replaces the old one. If the previous value was a binary or
-          string, it is freed with <c><![CDATA[free()]]></c>.</p>
+          string, it is freed with <c>free()</c>.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry where the object is to be
+          <item><c>reg</c> is the registry where the object is to be
             placed.</item>
-          <item><c><![CDATA[key]]></c> is the object name.</item>
-          <item><c><![CDATA[s]]></c> is the string to assign. The string itself
+          <item><c>key</c> is the object name.</item>
+          <item><c>s</c> is the string to assign. The string itself
             must have been created through a single call to
-            <c><![CDATA[malloc()]]></c> or similar a function,
+            <c>malloc()</c> or similar a function,
             so that the registry can later delete it if
-            necessary by calling <c><![CDATA[free()]]></c>.</item>
+            necessary by calling <c>free()</c>.</item>
         </list>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
       </desc>
@@ -516,36 +516,36 @@
         <v>v (see below)</v>
       </type>
       <desc>
-        <p>Creates a key-value pair with the specified <c><![CDATA[key]]></c>
-          whose value is specified by <c><![CDATA[v]]></c>. If an object already
-          exists with the same <c><![CDATA[key]]></c>, the new value replaces
+        <p>Creates a key-value pair with the specified <c>key</c>
+          whose value is specified by <c>v</c>. If an object already
+          exists with the same <c>key</c>, the new value replaces
           the old one. If the previous value was a binary or string, it is freed
-          with <c><![CDATA[free()]]></c>.</p>
+          with <c>free()</c>.</p>
         <list type="bulleted">
           <item>
-            <p><c><![CDATA[reg]]></c> is the registry where the object is to be
+            <p><c>reg</c> is the registry where the object is to be
               placed.</p>
           </item>
           <item>
-            <p><c><![CDATA[key]]></c> is the object name.</p>
+            <p><c>key</c> is the object name.</p>
           </item>
           <item>
-            <p><c><![CDATA[flags]]></c> indicates the type of the object
-              specified by <c><![CDATA[v]]></c>. Flags must be one of
+            <p><c>flags</c> indicates the type of the object
+              specified by <c>v</c>. Flags must be one of
               <c>EI_INT</c>, <c>EI_FLT</c>, <c>EI_STR</c>, and <c>EI_BIN</c>,
               indicating whether
-              <c><![CDATA[v]]></c> is <c><![CDATA[int]]></c>,
-              <c><![CDATA[double]]></c>, <c><![CDATA[char*]]></c>, or
-              <c><![CDATA[void*]]></c>.</p>
-            <p>If <c><![CDATA[flags]]></c> is <c>EI_BIN</c>, a fifth argument
-              <c><![CDATA[size]]></c> is required, indicating the size
-              in bytes of the object pointed to by <c><![CDATA[v]]></c>.</p>
+              <c>v</c> is <c>int</c>,
+              <c>double</c>, <c>char*</c>, or
+              <c>void*</c>.</p>
+            <p>If <c>flags</c> is <c>EI_BIN</c>, a fifth argument
+              <c>size</c> is required, indicating the size
+              in bytes of the object pointed to by <c>v</c>.</p>
           </item>
         </list>
         <p>If you wish to store an arbitrary pointer in the registry,
-          specify a <c><![CDATA[size]]></c> of <c>0</c>. In this case, the
+          specify a <c>size</c> of <c>0</c>. In this case, the
           object itself is not transferred by an
-          <c><![CDATA[ei_reg_dump()]]></c> operation, only the pointer
+          <c>ei_reg_dump()</c> operation, only the pointer
           value.</p>
         <p>Returns <c>0</c> on success, otherwise <c>-1</c>.</p>
       </desc>
@@ -562,11 +562,11 @@
       <desc>
         <p>Returns information about an object.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry containing the object.
+          <item><c>reg</c> is the registry containing the object.
           </item>
-          <item><c><![CDATA[key]]></c> is the object name.</item>
-          <item><c><![CDATA[obuf]]></c> is a pointer to an
-            <c><![CDATA[ei_reg_stat]]></c> structure, defined as follows:</item>
+          <item><c>key</c> is the object name.</item>
+          <item><c>obuf</c> is a pointer to an
+            <c>ei_reg_stat</c> structure, defined as follows:</item>
         </list>
         <code type="none"><![CDATA[
 struct ei_reg_stat {
@@ -574,17 +574,17 @@ struct ei_reg_stat {
   int size;
 };
         ]]></code>
-        <p>In <c><![CDATA[attr]]></c> the attributes of the object are stored
+        <p>In <c>attr</c> the attributes of the object are stored
           as the logical <em>OR</em> of its type (one of <c>EI_INT</c>,
           <c>EI_FLT</c>, <c>EI_BIN</c>, and <c>EI_STR</c>),
           whether it is marked for deletion (<c>EI_DELET</c>), and whether it
           has been modified since the last backup to <c>Mnesia</c>
           (<c>EI_DIRTY</c>).</p>
-        <p>Field <c><![CDATA[size]]></c> indicates the size in bytes required
+        <p>Field <c>size</c> indicates the size in bytes required
           to store <c>EI_STR</c> (including the terminating <c>0</c>) and
           <c>EI_BIN</c> objects, or <c>0</c> for <c>EI_INT</c> and
           <c>EI_FLT</c>.</p>
-        <p>Returns <c>0</c> and initializes <c><![CDATA[obuf]]></c> on success,
+        <p>Returns <c>0</c> and initializes <c>obuf</c> on success,
           otherwise <c>-1</c>.</p>
       </desc>
     </func>
@@ -601,10 +601,10 @@ struct ei_reg_stat {
           returned by this function, you can see whether the size of the
           registry is suitable for the amount of data it contains.</p>
         <list type="bulleted">
-          <item><c><![CDATA[reg]]></c> is the registry to return information
+          <item><c>reg</c> is the registry to return information
             about.</item>
-          <item><c><![CDATA[obuf]]></c> is a pointer to an
-            <c><![CDATA[ei_reg_tabstat]]></c> structure, defined as follows:
+          <item><c>obuf</c> is a pointer to an
+            <c>ei_reg_tabstat</c> structure, defined as follows:
           </item>
         </list>
         <code type="none"><![CDATA[
@@ -615,21 +615,21 @@ struct ei_reg_tabstat {
   int collisions; 
 };
         ]]></code>
-        <p>Field <c><![CDATA[size]]></c> indicates the number of hash positions
+        <p>Field <c>size</c> indicates the number of hash positions
           in the registry. This is the number you provided when you
           created or last resized the registry, rounded up to the nearest
           prime number.</p>
         <list type="bulleted">
-          <item><c><![CDATA[nelem]]></c> indicates the number of elements stored
+          <item><c>nelem</c> indicates the number of elements stored
             in the registry. It includes objects that are deleted but not
             purged.</item>
-          <item><c><![CDATA[npos]]></c> indicates the number of unique positions
+          <item><c>npos</c> indicates the number of unique positions
             that are occupied in the registry.</item>
-          <item><c><![CDATA[collisions]]></c> indicates how many elements are
+          <item><c>collisions</c> indicates how many elements are
             sharing positions in the registry.</item>
         </list>
         <p>On success, <c>0</c> is returned and
-          <c><![CDATA[obuf]]></c> is initialized to contain table statistics,
+          <c>obuf</c> is initialized to contain table statistics,
           otherwise <c>-1</c> is returned.</p>
       </desc>
     </func>