diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 7a270eb..84a7e57 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -1798,243 +1798,276 @@
 
    <table id="functions-string-other">
     <title>Other String Functions</title>
-    <tgroup cols="5">
+    <tgroup cols="2">
+     <colspec colname="col1" align="left" colwidth="0.25*"/>
+     <colspec colname="col2" align="left" colwidth="1*"/>
      <thead>
       <row>
        <entry>Function</entry>
-       <entry>Return Type</entry>
-       <entry>Description</entry>
-       <entry>Example</entry>
-       <entry>Result</entry>
+       <entry>Description<?br?>Signature<?br?>Example(s)</entry>
       </row>
      </thead>
 
      <tbody>
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>ascii</primary>
         </indexterm>
-        <literal><function>ascii(<parameter>string</parameter>)</function></literal>
+        <function>ascii</function>
        </entry>
-       <entry><type>int</type></entry>
        <entry>
-        <acronym>ASCII</acronym> code of the first character of the
-        argument.  For <acronym>UTF8</acronym> returns the Unicode code
-        point of the character.  For other multibyte encodings, the
-        argument must be an <acronym>ASCII</acronym> character.
+        Returns the numeric code of the first character of the argument.
+        In <acronym>UTF8</acronym> encoding, returns the Unicode code point
+        of the character.  In other multibyte encodings, the argument must
+        be an <acronym>ASCII</acronym> character.
+        <?br?>
+        <function>ascii</function> ( <type>text</type> )
+        <returnvalue>integer</returnvalue>
+        <?br?>
+        <literal>ascii('x')</literal>
+        <returnvalue>120</returnvalue>
        </entry>
-       <entry><literal>ascii('x')</literal></entry>
-       <entry><literal>120</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>btrim</primary>
         </indexterm>
-        <literal><function>btrim(<parameter>string</parameter> <type>text</type>
-        <optional>, <parameter>characters</parameter> <type>text</type></optional>)</function></literal>
+        <function>btrim</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Remove the longest string consisting only of characters
+        Removes the longest string consisting only of characters
         in <parameter>characters</parameter> (a space by default)
-        from the start and end of <parameter>string</parameter>
+        from the start and end of <parameter>string</parameter>.
+        <?br?>
+        <function>btrim</function> ( <parameter>string</parameter> <type>text</type>
+        <optional>, <parameter>characters</parameter> <type>text</type> </optional> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>btrim('xyxtrimyyx', 'xyz')</literal>
+        <returnvalue>trim</returnvalue>
        </entry>
-       <entry><literal>btrim('xyxtrimyyx', 'xyz')</literal></entry>
-       <entry><literal>trim</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>chr</primary>
         </indexterm>
-        <literal><function>chr(<type>int</type>)</function></literal>
+        <function>chr</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Character with the given code. For <acronym>UTF8</acronym> the
-        argument is treated as a Unicode code point. For other multibyte
-        encodings the argument must designate an
-        <acronym>ASCII</acronym> character.  The NULL (0) character is not
-        allowed because text data types cannot store such bytes.
+        Returns the character with the given
+        code. In <acronym>UTF8</acronym> encoding the argument is treated as
+        a Unicode code point. In other multibyte encodings the argument must
+        designate an <acronym>ASCII</acronym> character.  The NULL (0)
+        character is not allowed because text data types cannot store such
+        bytes.
+        <?br?>
+        <function>chr</function> ( <type>integer</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>chr(65)</literal>
+        <returnvalue>A</returnvalue>
        </entry>
-       <entry><literal>chr(65)</literal></entry>
-       <entry><literal>A</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>concat</primary>
         </indexterm>
-        <literal><function>concat(<parameter>str</parameter> <type>"any"</type>
-         [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</function></literal>
+        <function>concat</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Concatenate the text representations of all the arguments.
+        Concatenates the text representations of all the arguments.
         NULL arguments are ignored.
+        <?br?>
+        <function>concat</function> ( <parameter>val</parameter> <type>"any"</type>
+         [, <parameter>val</parameter> <type>"any"</type> [, ...] ] )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>concat('abcde', 2, NULL, 22)</literal>
+        <returnvalue>abcde222</returnvalue>
        </entry>
-       <entry><literal>concat('abcde', 2, NULL, 22)</literal></entry>
-       <entry><literal>abcde222</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>concat_ws</primary>
         </indexterm>
-        <literal><function>concat_ws(<parameter>sep</parameter> <type>text</type>,
-        <parameter>str</parameter> <type>"any"</type>
-        [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</function></literal>
+        <function>concat_ws</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Concatenate all but the first argument with separators. The first
+        Concatenates all but the first argument, with separators. The first
         argument is used as the separator string. NULL arguments are ignored.
+        <?br?>
+        <function>concat_ws</function> ( <parameter>sep</parameter> <type>text</type>,
+        <parameter>val</parameter> <type>"any"</type>
+        [, <parameter>val</parameter> <type>"any"</type> [, ...] ] )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>concat_ws(',', 'abcde', 2, NULL, 22)</literal>
+        <returnvalue>abcde,2,22</returnvalue>
        </entry>
-       <entry><literal>concat_ws(',', 'abcde', 2, NULL, 22)</literal></entry>
-       <entry><literal>abcde,2,22</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>format</primary>
         </indexterm>
-        <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
-        [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ])</literal>
+        <function>format</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-         Format arguments according to a format string.
+         Formats arguments according to a format string;
+         see <xref linkend="functions-string-format"/>.
          This function is similar to the C function <function>sprintf</function>.
-         See <xref linkend="functions-string-format"/>.
+        <?br?>
+        <function>format</function> ( <parameter>formatstr</parameter> <type>text</type>
+        [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ] )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>format('Hello %s, %1$s', 'World')</literal>
+        <returnvalue>Hello World, World</returnvalue>
        </entry>
-       <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
-       <entry><literal>Hello World, World</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>initcap</primary>
         </indexterm>
-        <literal><function>initcap(<parameter>string</parameter>)</function></literal>
+        <function>initcap</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Convert the first letter of each word to upper case and the
+        Converts the first letter of each word to upper case and the
         rest to lower case. Words are sequences of alphanumeric
         characters separated by non-alphanumeric characters.
+        <?br?>
+        <function>initcap</function> ( <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>initcap('hi THOMAS')</literal>
+        <returnvalue>Hi Thomas</returnvalue>
        </entry>
-       <entry><literal>initcap('hi THOMAS')</literal></entry>
-       <entry><literal>Hi Thomas</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>left</primary>
         </indexterm>
-        <literal><function>left(<parameter>string</parameter> <type>text</type>,
-        <parameter>n</parameter> <type>int</type>)</function></literal>
+        <function>left</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Return first <replaceable>n</replaceable> characters in the
-        string, or when <replaceable>n</replaceable> is negative, return
-        all but last |<replaceable>n</replaceable>| characters
-        </entry>
-       <entry><literal>left('abcde', 2)</literal></entry>
-       <entry><literal>ab</literal></entry>
+        Returns first <replaceable>n</replaceable> characters in the
+        string, or when <replaceable>n</replaceable> is negative, returns
+        all but last |<replaceable>n</replaceable>| characters.
+        <?br?>
+        <function>left</function> ( <parameter>string</parameter> <type>text</type>,
+        <parameter>n</parameter> <type>integer</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>left('abcde', 2)</literal>
+        <returnvalue>ab</returnvalue>
+       </entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>length</primary>
         </indexterm>
-        <literal><function>length(<parameter>string</parameter>)</function></literal>
+        <function>length</function>
        </entry>
-       <entry><type>int</type></entry>
        <entry>
-        Number of characters in <parameter>string</parameter>
+        Returns the number of characters in the string.
+        <?br?>
+        <function>length</function> ( <type>text</type> )
+        <returnvalue>integer</returnvalue>
+        <?br?>
+        <literal>length('jose')</literal>
+        <returnvalue>4</returnvalue>
        </entry>
-       <entry><literal>length('jose')</literal></entry>
-       <entry><literal>4</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>lpad</primary>
         </indexterm>
-        <literal><function>lpad(<parameter>string</parameter> <type>text</type>,
-        <parameter>length</parameter> <type>int</type>
-        <optional>, <parameter>fill</parameter> <type>text</type></optional>)</function></literal>
+        <function>lpad</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Extend the <parameter>string</parameter> to length
+        Extends the <parameter>string</parameter> to length
         <parameter>length</parameter> by prepending the characters
         <parameter>fill</parameter> (a space by default).  If the
         <parameter>string</parameter> is already longer than
-        <parameter>length</parameter> then it is truncated (on the
-        right).
+        <parameter>length</parameter> then it is truncated (on the right).
+        <?br?>
+        <function>lpad</function> ( <parameter>string</parameter> <type>text</type>,
+        <parameter>length</parameter> <type>integer</type>
+        <optional>, <parameter>fill</parameter> <type>text</type> </optional> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>lpad('hi', 5, 'xy')</literal>
+        <returnvalue>xyxhi</returnvalue>
        </entry>
-       <entry><literal>lpad('hi', 5, 'xy')</literal></entry>
-       <entry><literal>xyxhi</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>ltrim</primary>
         </indexterm>
-        <literal><function>ltrim(<parameter>string</parameter> <type>text</type>
-        <optional>, <parameter>characters</parameter> <type>text</type></optional>)</function></literal>
+        <function>ltrim</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Remove the longest string containing only characters from
+        Removes the longest string containing only characters from
         <parameter>characters</parameter> (a space by default) from the start of
-        <parameter>string</parameter>
+        <parameter>string</parameter>.
+        <?br?>
+        <function>ltrim</function> ( <parameter>string</parameter> <type>text</type>
+        <optional>, <parameter>characters</parameter> <type>text</type> </optional> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>ltrim('zzzytest', 'xyz')</literal>
+        <returnvalue>test</returnvalue>
        </entry>
-       <entry><literal>ltrim('zzzytest', 'xyz')</literal></entry>
-       <entry><literal>test</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>md5</primary>
         </indexterm>
-        <literal><function>md5(<parameter>string</parameter>)</function></literal>
+        <function>md5</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        MD5 <link linkend="functions-hash-note">hash</link>, with
-        the result written in hexadecimal
+        Computes MD5 <link linkend="functions-hash-note">hash</link>, with
+        the result written in hexadecimal.
+        <?br?>
+        <function>md5</function> ( <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>md5('abc')</literal>
+        <returnvalue>900150983cd24fb0&zwsp;d6963f7d28e17f72</returnvalue>
        </entry>
-       <entry><literal>md5('abc')</literal></entry>
-       <entry><literal>900150983cd24fb0 d6963f7d28e17f72</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>parse_ident</primary>
         </indexterm>
-        <literal><function>parse_ident(<parameter>qualified_identifier</parameter> <type>text</type>
-           [, <parameter>strictmode</parameter> <type>boolean</type> DEFAULT true ] )</function></literal>
+        <function>parse_ident</function>
        </entry>
-       <entry><type>text[]</type></entry>
        <entry>
-        Split <parameter>qualified_identifier</parameter> into an array of
+        Splits <parameter>qualified_identifier</parameter> into an array of
         identifiers, removing any quoting of individual identifiers.  By
         default, extra characters after the last identifier are considered an
         error; but if the second parameter is <literal>false</literal>, then such
@@ -2042,417 +2075,513 @@
         names for objects like functions.) Note that this function does not
         truncate over-length identifiers. If you want truncation you can cast
         the result to <type>name[]</type>.
+        <?br?>
+        <function>parse_ident</function> ( <parameter>qualified_identifier</parameter> <type>text</type>
+        [, <parameter>strictmode</parameter> <type>boolean</type> <literal>DEFAULT</literal> <literal>true</literal> ] )
+        <returnvalue>text[]</returnvalue>
+        <?br?>
+        <literal>parse_ident('"SomeSchema".someTable')</literal>
+        <returnvalue>{SomeSchema,sometable}</returnvalue>
        </entry>
-       <entry><literal>parse_ident('"SomeSchema".someTable')</literal></entry>
-       <entry><literal>{SomeSchema,sometable}</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>pg_client_encoding</primary>
         </indexterm>
-        <literal><function>pg_client_encoding()</function></literal>
+        <function>pg_client_encoding</function>
        </entry>
-       <entry><type>name</type></entry>
        <entry>
-        Current client encoding name
+        Returns current client encoding name.
+        <?br?>
+        <function>pg_client_encoding</function> ( )
+        <returnvalue>name</returnvalue>
+        <?br?>
+        <literal>pg_client_encoding()</literal>
+        <returnvalue>SQL_ASCII</returnvalue>
        </entry>
-       <entry><literal>pg_client_encoding()</literal></entry>
-       <entry><literal>SQL_ASCII</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>quote_ident</primary>
         </indexterm>
-        <literal><function>quote_ident(<parameter>string</parameter> <type>text</type>)</function></literal>
+        <function>quote_ident</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Return the given string suitably quoted to be used as an identifier
+        Returns the given string suitably quoted to be used as an identifier
         in an <acronym>SQL</acronym> statement string.
         Quotes are added only if necessary (i.e., if the string contains
         non-identifier characters or would be case-folded).
         Embedded quotes are properly doubled.
         See also <xref linkend="plpgsql-quote-literal-example"/>.
+        <?br?>
+        <function>quote_ident</function> ( <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>quote_ident('Foo bar')</literal>
+        <returnvalue>"Foo bar"</returnvalue>
        </entry>
-       <entry><literal>quote_ident('Foo bar')</literal></entry>
-       <entry><literal>"Foo bar"</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>quote_literal</primary>
         </indexterm>
-        <literal><function>quote_literal(<parameter>string</parameter> <type>text</type>)</function></literal>
+        <function>quote_literal</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Return the given string suitably quoted to be used as a string literal
+        Returns the given string suitably quoted to be used as a string literal
         in an <acronym>SQL</acronym> statement string.
         Embedded single-quotes and backslashes are properly doubled.
         Note that <function>quote_literal</function> returns null on null
         input; if the argument might be null,
         <function>quote_nullable</function> is often more suitable.
         See also <xref linkend="plpgsql-quote-literal-example"/>.
+        <?br?>
+        <function>quote_literal</function> ( <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>quote_literal(E'O\'Reilly')</literal>
+        <returnvalue>'O''Reilly'</returnvalue>
        </entry>
-       <entry><literal>quote_literal(E'O\'Reilly')</literal></entry>
-       <entry><literal>'O''Reilly'</literal></entry>
       </row>
 
       <row>
-       <entry><literal><function>quote_literal(<parameter>value</parameter> <type>anyelement</type>)</function></literal></entry>
-       <entry><type>text</type></entry>
+       <entry valign="top"><function>quote_literal</function></entry>
        <entry>
-        Coerce the given value to text and then quote it as a literal.
+        Coerces the given value to text and then quotes it as a literal.
         Embedded single-quotes and backslashes are properly doubled.
+        <?br?>
+        <function>quote_literal</function> ( <type>anyelement</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>quote_literal(42.5)</literal>
+        <returnvalue>'42.5'</returnvalue>
        </entry>
-       <entry><literal>quote_literal(42.5)</literal></entry>
-       <entry><literal>'42.5'</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>quote_nullable</primary>
         </indexterm>
-        <literal><function>quote_nullable(<parameter>string</parameter> <type>text</type>)</function></literal>
+        <function>quote_nullable</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Return the given string suitably quoted to be used as a string literal
+        Returns the given string suitably quoted to be used as a string literal
         in an <acronym>SQL</acronym> statement string; or, if the argument
-        is null, return <literal>NULL</literal>.
+        is null, returns <literal>NULL</literal>.
         Embedded single-quotes and backslashes are properly doubled.
         See also <xref linkend="plpgsql-quote-literal-example"/>.
+        <?br?>
+        <function>quote_nullable</function> ( <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>quote_nullable(NULL)</literal>
+        <returnvalue>NULL</returnvalue>
        </entry>
-       <entry><literal>quote_nullable(NULL)</literal></entry>
-       <entry><literal>NULL</literal></entry>
       </row>
 
       <row>
-       <entry><literal><function>quote_nullable(<parameter>value</parameter> <type>anyelement</type>)</function></literal></entry>
-       <entry><type>text</type></entry>
+       <entry valign="top"><function>quote_nullable</function></entry>
        <entry>
-        Coerce the given value to text and then quote it as a literal;
-        or, if the argument is null, return <literal>NULL</literal>.
+        Coerces the given value to text and then quotes it as a literal;
+        or, if the argument is null, returns <literal>NULL</literal>.
         Embedded single-quotes and backslashes are properly doubled.
+        <?br?>
+        <function>quote_nullable</function> ( <type>anyelement</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>quote_nullable(42.5)</literal>
+        <returnvalue>'42.5'</returnvalue>
        </entry>
-       <entry><literal>quote_nullable(42.5)</literal></entry>
-       <entry><literal>'42.5'</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>regexp_match</primary>
         </indexterm>
-        <literal><function>regexp_match(<parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type>])</function></literal>
+        <function>regexp_match</function>
        </entry>
-       <entry><type>text[]</type></entry>
        <entry>
-        Return captured substring(s) resulting from the first match of a POSIX
-        regular expression to the <parameter>string</parameter> (see
-        <xref linkend="functions-posix-regexp"/> for more information)
+        Returns captured substring(s) resulting from the first match of a POSIX
+        regular expression to the <parameter>string</parameter>; see
+        <xref linkend="functions-posix-regexp"/>.
+        <?br?>
+        <function>regexp_match</function> ( <parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type> ] )
+        <returnvalue>text[]</returnvalue>
+        <?br?>
+        <literal>regexp_match('foobarbequebaz', '(bar)(beque)')</literal>
+        <returnvalue>{bar,beque}</returnvalue>
        </entry>
-       <entry><literal>regexp_match('foobarbequebaz', '(bar)(beque)')</literal></entry>
-       <entry><literal>{bar,beque}</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>regexp_matches</primary>
         </indexterm>
-        <literal><function>regexp_matches(<parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type>])</function></literal>
+        <function>regexp_matches</function>
        </entry>
-       <entry><type>setof text[]</type></entry>
        <entry>
-        Return captured substring(s) resulting from matching a POSIX regular
-        expression to the <parameter>string</parameter> (see
-        <xref linkend="functions-posix-regexp"/> for more information)
+        Returns captured substring(s) resulting from matching a POSIX regular
+        expression to the <parameter>string</parameter>; see
+        <xref linkend="functions-posix-regexp"/>.
+        <?br?>
+        <function>regexp_matches</function> ( <parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type> ] )
+        <returnvalue>setof text[]</returnvalue>
+        <?br?>
+        <literal>regexp_matches('foobarbequebaz', 'ba.', 'g')</literal>
+        <returnvalue>{bar}<?br?>{baz}</returnvalue><?br?>(2 rows)
        </entry>
-       <entry><literal>regexp_matches('foobarbequebaz', 'ba.', 'g')</literal></entry>
-       <entry><literal>{bar}</literal><para><literal>{baz}</literal></para> (2 rows)</entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>regexp_replace</primary>
         </indexterm>
-        <literal><function>regexp_replace(<parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type>, <parameter>replacement</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type>])</function></literal>
+        <function>regexp_replace</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Replace substring(s) matching a POSIX regular expression (see
-        <xref linkend="functions-posix-regexp"/> for more information)
+        Replaces substring(s) matching a POSIX regular expression; see
+        <xref linkend="functions-posix-regexp"/>.
+        <?br?>
+        <function>regexp_replace</function> ( <parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type>, <parameter>replacement</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type> ] )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>regexp_replace('Thomas', '.[mN]a.', 'M')</literal>
+        <returnvalue>ThM</returnvalue>
        </entry>
-       <entry><literal>regexp_replace('Thomas', '.[mN]a.', 'M')</literal></entry>
-       <entry><literal>ThM</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>regexp_split_to_array</primary>
         </indexterm>
-        <literal><function>regexp_split_to_array(<parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type> ])</function></literal>
+        <function>regexp_split_to_array</function>
        </entry>
-       <entry><type>text[]</type></entry>
        <entry>
-        Split <parameter>string</parameter> using a POSIX regular expression as
-        the delimiter (see <xref linkend="functions-posix-regexp"/> for more
-        information)
+        Splits <parameter>string</parameter> using a POSIX regular
+        expression as the delimiter; see
+        <xref linkend="functions-posix-regexp"/>.
+        <?br?>
+        <function>regexp_split_to_array</function> ( <parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type> ] )
+        <returnvalue>text[]</returnvalue>
+        <?br?>
+        <literal>regexp_split_to_array('hello world', '\s+')</literal>
+        <returnvalue>{hello,world}</returnvalue>
        </entry>
-       <entry><literal>regexp_split_to_array('hello world', '\s+')</literal></entry>
-       <entry><literal>{hello,world}</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>regexp_split_to_table</primary>
         </indexterm>
-        <literal><function>regexp_split_to_table(<parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type>])</function></literal>
+        <function>regexp_split_to_table</function>
        </entry>
-       <entry><type>setof text</type></entry>
        <entry>
-        Split <parameter>string</parameter> using a POSIX regular expression as
-        the delimiter (see <xref linkend="functions-posix-regexp"/> for more
-        information)
+        Splits <parameter>string</parameter> using a POSIX regular
+        expression as the delimiter; see
+        <xref linkend="functions-posix-regexp"/>.
+        <?br?>
+        <function>regexp_split_to_table</function> ( <parameter>string</parameter> <type>text</type>, <parameter>pattern</parameter> <type>text</type> [, <parameter>flags</parameter> <type>text</type> ] )
+        <returnvalue>setof text</returnvalue>
+        <?br?>
+        <literal>regexp_split_to_table('hello world', '\s+')</literal>
+        <returnvalue>hello<?br?>world</returnvalue><?br?>(2 rows)
        </entry>
-       <entry><literal>regexp_split_to_table('hello world', '\s+')</literal></entry>
-       <entry><literal>hello</literal><para><literal>world</literal></para> (2 rows)</entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>repeat</primary>
         </indexterm>
-        <literal><function>repeat(<parameter>string</parameter> <type>text</type>, <parameter>number</parameter> <type>int</type>)</function></literal>
+        <function>repeat</function>
+       </entry>
+       <entry>
+        Repeats <parameter>string</parameter> the specified
+        <parameter>number</parameter> of times.
+        <?br?>
+        <function>repeat</function> ( <parameter>string</parameter> <type>text</type>, <parameter>number</parameter> <type>integer</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>repeat('Pg', 4)</literal>
+        <returnvalue>PgPgPgPg</returnvalue>
        </entry>
-       <entry><type>text</type></entry>
-       <entry>Repeat <parameter>string</parameter> the specified
-       <parameter>number</parameter> of times</entry>
-       <entry><literal>repeat('Pg', 4)</literal></entry>
-       <entry><literal>PgPgPgPg</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>replace</primary>
         </indexterm>
-        <literal><function>replace(<parameter>string</parameter> <type>text</type>,
-        <parameter>from</parameter> <type>text</type>,
-        <parameter>to</parameter> <type>text</type>)</function></literal>
+        <function>replace</function>
        </entry>
-       <entry><type>text</type></entry>
-       <entry>Replace all occurrences in <parameter>string</parameter> of substring
-        <parameter>from</parameter> with substring <parameter>to</parameter>
+       <entry>
+        Replaces all occurrences in <parameter>string</parameter> of
+        substring <parameter>from</parameter> with
+        substring <parameter>to</parameter>.
+        <?br?>
+        <function>replace</function> ( <parameter>string</parameter> <type>text</type>,
+        <parameter>from</parameter> <type>text</type>,
+        <parameter>to</parameter> <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>replace('abcdefabcdef', 'cd', 'XX')</literal>
+        <returnvalue>abXXefabXXef</returnvalue>
        </entry>
-       <entry><literal>replace('abcdefabcdef', 'cd', 'XX')</literal></entry>
-       <entry><literal>abXXefabXXef</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>reverse</primary>
         </indexterm>
-        <literal><function>reverse(<parameter>str</parameter>)</function></literal>
+        <function>reverse</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Reverse the order of the characters in <parameter>string</parameter>
+        Reverses the order of the characters in the string.
+        <?br?>
+        <function>reverse</function> ( <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>reverse('abcde')</literal>
+        <returnvalue>edcba</returnvalue>
        </entry>
-       <entry><literal>reverse('abcde')</literal></entry>
-       <entry><literal>edcba</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>right</primary>
         </indexterm>
-        <literal><function>right(<parameter>string</parameter> <type>text</type>,
-         <parameter>n</parameter> <type>int</type>)</function></literal>
+        <function>right</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Return last <replaceable>n</replaceable> characters in the string,
-        or when <replaceable>n</replaceable> is negative, return all but
-        first |<replaceable>n</replaceable>| characters
+        Returns last <replaceable>n</replaceable> characters in the string,
+        or when <replaceable>n</replaceable> is negative, returns all but
+        first |<replaceable>n</replaceable>| characters.
+        <?br?>
+        <function>right</function> ( <parameter>string</parameter> <type>text</type>,
+         <parameter>n</parameter> <type>integer</type> )
+<type></type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>right('abcde', 2)</literal>
+        <returnvalue>de</returnvalue>
        </entry>
-       <entry><literal>right('abcde', 2)</literal></entry>
-       <entry><literal>de</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>rpad</primary>
         </indexterm>
-        <literal><function>rpad(<parameter>string</parameter> <type>text</type>,
-        <parameter>length</parameter> <type>int</type>
-        <optional>, <parameter>fill</parameter> <type>text</type></optional>)</function></literal>
+        <function>rpad</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Extend the <parameter>string</parameter> to length
+        Extends the <parameter>string</parameter> to length
         <parameter>length</parameter> by appending the characters
         <parameter>fill</parameter> (a space by default).  If the
         <parameter>string</parameter> is already longer than
         <parameter>length</parameter> then it is truncated.
+        <?br?>
+        <function>rpad</function> ( <parameter>string</parameter> <type>text</type>,
+        <parameter>length</parameter> <type>integer</type>
+        <optional>, <parameter>fill</parameter> <type>text</type> </optional> )
+<type></type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>rpad('hi', 5, 'xy')</literal>
+        <returnvalue>hixyx</returnvalue>
        </entry>
-       <entry><literal>rpad('hi', 5, 'xy')</literal></entry>
-       <entry><literal>hixyx</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>rtrim</primary>
         </indexterm>
-        <literal><function>rtrim(<parameter>string</parameter> <type>text</type>
-         <optional>, <parameter>characters</parameter> <type>text</type></optional>)</function></literal>
+        <function>rtrim</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Remove the longest string containing only characters from
+        Removes the longest string containing only characters from
         <parameter>characters</parameter> (a space by default) from the end of
-        <parameter>string</parameter>
+        <parameter>string</parameter>.
+        <?br?>
+        <function>rtrim</function> ( <parameter>string</parameter> <type>text</type>
+         <optional>, <parameter>characters</parameter> <type>text</type> </optional> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>rtrim('testxxzx', 'xyz')</literal>
+        <returnvalue>test</returnvalue>
        </entry>
-       <entry><literal>rtrim('testxxzx', 'xyz')</literal></entry>
-       <entry><literal>test</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>split_part</primary>
         </indexterm>
-        <literal><function>split_part(<parameter>string</parameter> <type>text</type>,
-        <parameter>delimiter</parameter> <type>text</type>,
-        <parameter>field</parameter> <type>int</type>)</function></literal>
+        <function>split_part</function>
        </entry>
-       <entry><type>text</type></entry>
-       <entry>Split <parameter>string</parameter> on <parameter>delimiter</parameter>
-        and return the given field (counting from one)
+       <entry>
+        Splits <parameter>string</parameter> on <parameter>delimiter</parameter>
+        and returns the <parameter>n</parameter>'th field (counting from one).
+        <?br?>
+        <function>split_part</function> ( <parameter>string</parameter> <type>text</type>,
+        <parameter>delimiter</parameter> <type>text</type>,
+        <parameter>n</parameter> <type>integer</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>split_part('abc~@~def~@~ghi', '~@~', 2)</literal>
+        <returnvalue>def</returnvalue>
        </entry>
-       <entry><literal>split_part('abc~@~def~@~ghi', '~@~', 2)</literal></entry>
-       <entry><literal>def</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>strpos</primary>
         </indexterm>
-        <literal><function>strpos(<parameter>string</parameter>, <parameter>substring</parameter>)</function></literal>
+        <function>strpos</function>
        </entry>
-       <entry><type>int</type></entry>
        <entry>
-        Location of specified substring (same as
-        <literal>position(<parameter>substring</parameter> in
-         <parameter>string</parameter>)</literal>, but note the reversed
-        argument order)
+        Returns location of specified <parameter>substring</parameter>
+        within <parameter>string</parameter>, or zero if it's not present.
+        (Same as <literal>position(<parameter>substring</parameter> in
+        <parameter>string</parameter>)</literal>, but note the reversed
+        argument order.)
+        <?br?>
+        <function>strpos</function> ( <parameter>string</parameter> <type>text</type>, <parameter>substring</parameter> <type>text</type> )
+        <returnvalue>integer</returnvalue>
+        <?br?>
+        <literal>strpos('high', 'ig')</literal>
+        <returnvalue>2</returnvalue>
        </entry>
-       <entry><literal>strpos('high', 'ig')</literal></entry>
-       <entry><literal>2</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>substr</primary>
         </indexterm>
-        <literal><function>substr(<parameter>string</parameter>, <parameter>from</parameter> <optional>, <parameter>count</parameter></optional>)</function></literal>
+        <function>substr</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Extract substring (same as
-        <literal>substring(<parameter>string</parameter> from <parameter>from</parameter> for <parameter>count</parameter>)</literal>)
+        Extracts substring starting at index <parameter>start</parameter>,
+        and extending for <parameter>count</parameter> characters if that is
+        specified.  (Same
+        as <literal>substring(<parameter>string</parameter>
+        from <parameter>start</parameter>
+        for <parameter>count</parameter>)</literal>.)
+        <?br?>
+        <function>substr</function> ( <parameter>string</parameter> <type>text</type>, <parameter>start</parameter> <type>integer</type> <optional>, <parameter>count</parameter> <type>integer</type> </optional> )
+<type></type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>substr('alphabet', 3, 2)</literal>
+        <returnvalue>ph</returnvalue>
        </entry>
-       <entry><literal>substr('alphabet', 3, 2)</literal></entry>
-       <entry><literal>ph</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>starts_with</primary>
         </indexterm>
-        <literal><function>starts_with(<parameter>string</parameter>, <parameter>prefix</parameter>)</function></literal>
+        <function>starts_with</function>
        </entry>
-       <entry><type>bool</type></entry>
        <entry>
-        Return true if <parameter>string</parameter> starts
-        with <parameter>prefix</parameter>
+        Returns true if <parameter>string</parameter> starts
+        with <parameter>prefix</parameter>.
+        <?br?>
+        <function>starts_with</function> ( <parameter>string</parameter> <type>text</type>, <parameter>prefix</parameter> <type>text</type> )
+        <returnvalue>boolean</returnvalue>
+        <?br?>
+        <literal>starts_with('alphabet', 'alph')</literal>
+        <returnvalue>t</returnvalue>
        </entry>
-       <entry><literal>starts_with('alphabet', 'alph')</literal></entry>
-       <entry><literal>t</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>to_ascii</primary>
         </indexterm>
-        <literal><function>to_ascii(<parameter>string</parameter> <type>text</type>
-        <optional>, <parameter>encoding</parameter> <type>text</type></optional>)</function></literal>
+        <function>to_ascii</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-       Convert <parameter>string</parameter> to <acronym>ASCII</acronym> from another encoding
-       (only supports conversion from  <literal>LATIN1</literal>, <literal>LATIN2</literal>, <literal>LATIN9</literal>,
-       and <literal>WIN1250</literal> encodings)
+        Converts <parameter>string</parameter> to <acronym>ASCII</acronym>
+        from another encoding, which may be identified by name or number;
+        if <parameter>encoding</parameter> is omitted the database encoding
+        is assumed.  The conversion consists primarily of dropping accents.
+        Conversion is only supported
+        from <literal>LATIN1</literal>, <literal>LATIN2</literal>,
+        <literal>LATIN9</literal>, and <literal>WIN1250</literal> encodings.
+        <?br?>
+        <function>to_ascii</function> ( <parameter>string</parameter> <type>text</type>
+        <optional>, <parameter>encoding</parameter> <type>name</type> or <type>integer</type> </optional> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>to_ascii('Kar&eacute;l')</literal>
+        <returnvalue>Karel</returnvalue>
        </entry>
-       <entry><literal>to_ascii('Karel')</literal></entry>
-       <entry><literal>Karel</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>to_hex</primary>
         </indexterm>
-        <literal><function>to_hex(<parameter>number</parameter> <type>int</type>
-        or <type>bigint</type>)</function></literal>
+        <function>to_hex</function>
        </entry>
-       <entry><type>text</type></entry>
-       <entry>Convert <parameter>number</parameter> to its equivalent hexadecimal
-        representation
+       <entry>
+        Converts <parameter>number</parameter> to its equivalent hexadecimal
+        representation.
+        <?br?>
+        <function>to_hex</function> ( <parameter>number</parameter>
+        <type>integer</type>
+        or <type>bigint</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>to_hex(2147483647)</literal>
+        <returnvalue>7fffffff</returnvalue>
        </entry>
-       <entry><literal>to_hex(2147483647)</literal></entry>
-       <entry><literal>7fffffff</literal></entry>
       </row>
 
       <row>
-       <entry>
+       <entry valign="top">
         <indexterm>
          <primary>translate</primary>
         </indexterm>
-        <literal><function>translate(<parameter>string</parameter> <type>text</type>,
-        <parameter>from</parameter> <type>text</type>,
-        <parameter>to</parameter> <type>text</type>)</function></literal>
+        <function>translate</function>
        </entry>
-       <entry><type>text</type></entry>
        <entry>
-        Any character in <parameter>string</parameter> that matches a
-        character in the <parameter>from</parameter> set is replaced by
-        the corresponding character in the <parameter>to</parameter>
+        Replaces each character in <parameter>string</parameter> that
+        matches a character in the <parameter>from</parameter> set with the
+        corresponding character in the <parameter>to</parameter>
         set. If <parameter>from</parameter> is longer than
         <parameter>to</parameter>, occurrences of the extra characters in
-        <parameter>from</parameter> are removed.
+        <parameter>from</parameter> are deleted.
+        <?br?>
+        <function>translate</function> ( <parameter>string</parameter> <type>text</type>,
+        <parameter>from</parameter> <type>text</type>,
+        <parameter>to</parameter> <type>text</type> )
+        <returnvalue>text</returnvalue>
+        <?br?>
+        <literal>translate('12345', '143', 'ax')</literal>
+        <returnvalue>a2x5</returnvalue>
        </entry>
-       <entry><literal>translate('12345', '143', 'ax')</literal></entry>
-       <entry><literal>a2x5</literal></entry>
       </row>
 
      </tbody>
@@ -8645,103 +8774,90 @@ CREATE TYPE rainbow AS ENUM ('red', 'orange', 'yellow', 'green', 'blue', 'purple
 
   <table id="functions-enum-table">
     <title>Enum Support Functions</title>
-    <tgroup cols="3">
-     <colspec colname="col1" colwidth="0.5*"/>
-     <colspec colname="col2" colwidth="1*"/>
-     <colspec colname="col3" colwidth="1*"/>
-     <spanspec spanname="name" namest="col1" nameend="col1" align="left"/>
-     <spanspec spanname="sig" namest="col2" nameend="col3" align="left"/>
-     <spanspec spanname="desc" namest="col2" nameend="col3" align="left"/>
-     <spanspec spanname="example" namest="col2" nameend="col2" align="left"/>
-     <spanspec spanname="exresult" namest="col3" nameend="col3" align="left"/>
+    <tgroup cols="2">
+     <colspec colname="col1" align="left" colwidth="0.25*"/>
+     <colspec colname="col2" align="left" colwidth="1*"/>
      <thead>
       <row>
-       <entry spanname="name" align="center" valign="middle" morerows="2">Function</entry>
-       <entry spanname="sig" align="center">Signature</entry>
-      </row>
-      <row>
-       <entry spanname="desc" align="center">Description</entry>
-      </row>
-      <row>
-       <entry spanname="example" align="center">Example</entry>
-       <entry spanname="exresult" align="center">Example Result</entry>
+       <entry>Function</entry>
+       <entry>Description<?br?>Signature<?br?>Example(s)</entry>
       </row>
      </thead>
      <tbody>
       <row>
-       <entry spanname="name" morerows="2">
+       <entry valign="top">
         <indexterm>
          <primary>enum_first</primary>
         </indexterm>
         <function>enum_first</function>
        </entry>
-       <entry spanname="sig"><function>enum_first</function>(<type>anyenum</type>) <returnvalue>anyenum</returnvalue></entry>
-      </row>
-      <row>
-       <entry spanname="desc">Returns the first value of the input enum type</entry>
-      </row>
-      <row>
-       <entry spanname="example"><literal>enum_first(&zwsp;null::rainbow)</literal></entry>
-       <entry spanname="exresult"><literal>red</literal></entry>
+       <entry>
+        Returns the first value of the input enum type.
+        <?br?>
+        <function>enum_first</function> ( <type>anyenum</type> )
+        <returnvalue>anyenum</returnvalue>
+        <?br?>
+        <literal>enum_first(&zwsp;null::rainbow)</literal>
+        <returnvalue>red</returnvalue>
+       </entry>
       </row>
       <row>
-       <entry spanname="name" morerows="2">
+       <entry valign="top">
         <indexterm>
          <primary>enum_last</primary>
         </indexterm>
         <function>enum_last</function>
        </entry>
-       <entry spanname="sig"><function>enum_last</function>(<type>anyenum</type>) <returnvalue>anyenum</returnvalue></entry>
-      </row>
-      <row>
-       <entry spanname="desc">Returns the last value of the input enum type</entry>
-      </row>
-      <row>
-       <entry spanname="example"><literal>enum_last(&zwsp;null::rainbow)</literal></entry>
-       <entry spanname="exresult"><literal>purple</literal></entry>
+       <entry>
+        Returns the last value of the input enum type.
+        <?br?>
+        <function>enum_last</function> ( <type>anyenum</type> )
+        <returnvalue>anyenum</returnvalue>
+        <?br?>
+        <literal>enum_last(&zwsp;null::rainbow)</literal>
+        <returnvalue>purple</returnvalue>
+       </entry>
       </row>
       <row>
-       <entry spanname="name" morerows="2">
+       <entry valign="top">
         <indexterm>
          <primary>enum_range</primary>
         </indexterm>
         <function>enum_range</function>
        </entry>
-       <entry spanname="sig"><function>enum_range</function>(<type>anyenum</type>) <returnvalue>anyarray</returnvalue></entry>
-      </row>
-      <row>
-       <entry spanname="desc">Returns all values of the input enum type in an ordered array</entry>
-      </row>
-      <row>
-       <entry spanname="example"><literal>enum_range(&zwsp;null::rainbow)</literal></entry>
-       <entry spanname="exresult"><literal>{red,orange,yellow,&zwsp;green,blue,purple}</literal></entry>
-      </row>
-      <row>
-       <entry spanname="name" morerows="4"><function>enum_range</function></entry>
-       <entry spanname="sig"><function>enum_range</function>(<type>anyenum</type>, <type>anyenum</type>) <returnvalue>anyarray</returnvalue></entry>
+       <entry>
+        Returns all values of the input enum type in an ordered array.
+        <?br?>
+        <function>enum_range</function> ( <type>anyenum</type> )
+        <returnvalue>anyarray</returnvalue>
+        <?br?>
+        <literal>enum_range(&zwsp;null::rainbow)</literal>
+        <returnvalue>{red,orange,yellow,&zwsp;green,blue,purple}</returnvalue>
+       </entry>
       </row>
       <row>
-       <entry spanname="desc">
+       <entry valign="top"><function>enum_range</function></entry>
+       <entry>
         Returns the range between the two given enum values, as an ordered
         array. The values must be from the same enum type. If the first
         parameter is null, the result will start with the first value of
         the enum type.
         If the second parameter is null, the result will end with the last
         value of the enum type.
+        <?br?>
+        <function>enum_range</function> ( <type>anyenum</type>, <type>anyenum</type> )
+        <returnvalue>anyarray</returnvalue>
+        <?br?>
+        <literal>enum_range(&zwsp;'orange'::rainbow, 'green'::rainbow)</literal>
+        <returnvalue>{orange,yellow,green}</returnvalue>
+        <?br?>
+        <literal>enum_range(NULL, 'green'::rainbow)</literal>
+        <returnvalue>{red,orange,&zwsp;yellow,green}</returnvalue>
+        <?br?>
+        <literal>enum_range(&zwsp;'orange'::rainbow, NULL)</literal>
+        <returnvalue>{orange,yellow,green,&zwsp;blue,purple}</returnvalue>
        </entry>
       </row>
-      <row>
-       <entry spanname="example"><literal>enum_range(&zwsp;'orange'::rainbow, 'green'::rainbow)</literal></entry>
-       <entry spanname="exresult"><literal>{orange,yellow,green}</literal></entry>
-      </row>
-      <row>
-       <entry spanname="example"><literal>enum_range(NULL, 'green'::rainbow)</literal></entry>
-       <entry spanname="exresult"><literal>{red,orange,yellow,&zwsp;green}</literal></entry>
-      </row>
-      <row>
-       <entry spanname="example"><literal>enum_range(&zwsp;'orange'::rainbow, NULL)</literal></entry>
-       <entry spanname="exresult"><literal>{orange,yellow,green,&zwsp;blue,purple}</literal></entry>
-      </row>
      </tbody>
     </tgroup>
    </table>
diff --git a/doc/src/sgml/stylesheet-common.xsl b/doc/src/sgml/stylesheet-common.xsl
index a13565e..105ed1c 100644
--- a/doc/src/sgml/stylesheet-common.xsl
+++ b/doc/src/sgml/stylesheet-common.xsl
@@ -103,4 +103,11 @@
   <xsl:apply-templates select="." mode="xref"/>
 </xsl:template>
 
+
+<!-- Support for explicit line breaks <?br?> within table cells -->
+
+<xsl:template match="processing-instruction('br')">
+  <br/>
+</xsl:template>
+
 </xsl:stylesheet>
diff --git a/doc/src/sgml/stylesheet-fo.xsl b/doc/src/sgml/stylesheet-fo.xsl
index 2aaae82..713159d 100644
--- a/doc/src/sgml/stylesheet-fo.xsl
+++ b/doc/src/sgml/stylesheet-fo.xsl
@@ -70,6 +70,11 @@
   <xsl:call-template name="inline.monoseq"/>
 </xsl:template>
 
+<!-- overrides stylesheet-common.xsl -->
+<xsl:template match="processing-instruction('br')">
+  <fo:block/>
+</xsl:template>
+
 <!-- bug fix from <https://sourceforge.net/p/docbook/bugs/1360/#831b> -->
 
 <xsl:template match="varlistentry/term" mode="xref-to">
