Modified patch attached and applied.  I made some style changes and had
some merge conflicts because wchar.c has changed since 8.1.

The change to libpq's PQdsplen() seems like a good one and I will
mention it in the release notes.

---------------------------------------------------------------------------

Martijn van Oosterhout wrote:
-- Start of PGP signed section.
> [Please CC any replies, thanks]
> 
> This patch has the same effect as the last one except it now uses the
> PQmblen and PQdsplen functions exported by libpq as suggested by Tom.
> This clears a lot of stuff from psql's mbprint.c which is a good thing.
> This means it should work for all for encodings (though I can't say I
> tested them all).
> 
> The PQdsplen function in libpq has been improved so it can actually
> work and provide the necessary information for formatting. That file
> (wchar.c) is actually shared with the backend but the backend doesn't
> use the dsplen functions, so it does add some dead code (on top of what
> was already there).
> 
> Note: this changes the PQdsplen function, it can now return zero or
> minus one which was not possible before. It doesn't appear anyone is
> actually using the functions other than psql but it is a change. The
> functions are not actually documentated anywhere so it's not like we're
> breaking a defined interface. The new semantics follow the Unicode
> standard.
> 
> The other uses of PQdsplen in psql (in ReportSyntaxErrorPosition) would
> seem to be slightly affected by the change, except it's not clear how
> psql should react to control characters in the string it's trying to
> print...
> 
> Patch available at:
> http://svana.org/kleptog/pgsql/psql-format.patch
> 
> Comments welcome,
> 
> Have a nice day,
> -- 
> Martijn van Oosterhout   <kleptog@svana.org>   http://svana.org/kleptog/
> > Patent. n. Genius is 5% inspiration and 95% perspiration. A patent is a
> > tool for doing 5% of the work and then sitting around waiting for someone
> > else to do the other 95% so you can sue them.

[ Attachment, skipping... ]
-- End of PGP section, PGP failed!

-- 
  Bruce Momjian                        |  http://candle.pha.pa.us
  pgman@candle.pha.pa.us               |  (610) 359-1001
  +  If your life is a hard drive,     |  13 Roberts Road
  +  Christ can be your backup.        |  Newtown Square, Pennsylvania 19073
Index: src/backend/utils/mb/wchar.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/mb/wchar.c,v
retrieving revision 1.52
diff -c -c -r1.52 wchar.c
*** src/backend/utils/mb/wchar.c        26 Dec 2005 19:30:44 -0000      1.52
--- src/backend/utils/mb/wchar.c        10 Feb 2006 00:23:32 -0000
***************
*** 23,28 ****
--- 23,35 ----
   * for the particular encoding. Note that if the encoding is only
   * supported in the client, you don't need to define
   * mb2wchar_with_len() function (SJIS is the case).
+  *
+  * Note: for the display output of psql to work properly, the return values
+  * of these functions must conform to the Unicode standard. In particular
+  * the NUL character is zero width and control characters are generally
+  * width -1. It is recommended that non-ASCII encodings refer their ASCII
+  * subset to the ASCII routines to ensure consistancy.
+  *
   */
  
  /*
***************
*** 53,58 ****
--- 60,70 ----
  static int
  pg_ascii_dsplen(const unsigned char *s)
  {
+       if (*s == '\0')
+               return 0;
+       if (*s < 0x20 || *s == 0x7f)
+               return -1;
+               
        return 1;
  }
  
***************
*** 125,131 ****
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = 1;
        return len;
  }
  
--- 137,143 ----
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = pg_ascii_dsplen(s);
        return len;
  }
  
***************
*** 156,162 ****
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = 1;
        return len;
  }
  
--- 168,174 ----
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = pg_ascii_dsplen(s);
        return len;
  }
  
***************
*** 244,250 ****
        if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = 1;
        return len;
  }
  
--- 256,262 ----
        if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = pg_ascii_dsplen(s);
        return len;
  }
  
***************
*** 304,310 ****
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = 1;
        return len;
  }
  
--- 316,322 ----
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = pg_ascii_dsplen(s);
        return len;
  }
  
***************
*** 320,326 ****
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = 1;
        return len;
  }
  
--- 332,338 ----
        else if (IS_HIGHBIT_SET(*s))
                len = 2;
        else
!               len = pg_ascii_dsplen(s);
        return len;
  }
  
***************
*** 419,428 ****
        return len;
  }
  
  static int
  pg_utf_dsplen(const unsigned char *s)
  {
!       return 1;                                       /* XXX fix me! */
  }
  
  /*
--- 431,609 ----
        return len;
  }
  
+ /*
+  * This is an implementation of wcwidth() and wcswidth() as defined in
+  * "The Single UNIX Specification, Version 2, The Open Group, 1997"
+  * <http://www.UNIX-systems.org/online.html>
+  *
+  * Markus Kuhn -- 2001-09-08 -- public domain
+  *
+  * customised for PostgreSQL
+  *
+  * original available at : http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+  */
+ 
+ struct mbinterval
+ {
+       unsigned short first;
+       unsigned short last;
+ };
+ 
+ /* auxiliary function for binary search in interval table */
+ static int
+ mbbisearch(pg_wchar ucs, const struct mbinterval *table, int max)
+ {
+       int                     min = 0;
+       int                     mid;
+ 
+       if (ucs < table[0].first || ucs > table[max].last)
+               return 0;
+       while (max >= min)
+       {
+               mid = (min + max) / 2;
+               if (ucs > table[mid].last)
+                       min = mid + 1;
+               else if (ucs < table[mid].first)
+                       max = mid - 1;
+               else
+                       return 1;
+       }
+ 
+       return 0;
+ }
+ 
+ 
+ /* The following functions define the column width of an ISO 10646
+  * character as follows:
+  *
+  *      - The null character (U+0000) has a column width of 0.
+  *
+  *      - Other C0/C1 control characters and DEL will lead to a return
+  *            value of -1.
+  *
+  *      - Non-spacing and enclosing combining characters (general
+  *            category code Mn or Me in the Unicode database) have a
+  *            column width of 0.
+  *
+  *      - Other format characters (general category code Cf in the Unicode
+  *            database) and ZERO WIDTH SPACE (U+200B) have a column width of 
0.
+  *
+  *      - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+  *            have a column width of 0.
+  *
+  *      - Spacing characters in the East Asian Wide (W) or East Asian
+  *            FullWidth (F) category as defined in Unicode Technical
+  *            Report #11 have a column width of 2.
+  *
+  *      - All remaining characters (including all printable
+  *            ISO 8859-1 and WGL4 characters, Unicode control characters,
+  *            etc.) have a column width of 1.
+  *
+  * This implementation assumes that wchar_t characters are encoded
+  * in ISO 10646.
+  */
+ 
+ static int
+ ucs_wcwidth(pg_wchar ucs)
+ {
+       /* sorted list of non-overlapping intervals of non-spacing characters */
+       static const struct mbinterval combining[] = {
+               {0x0300, 0x034E}, {0x0360, 0x0362}, {0x0483, 0x0486},
+               {0x0488, 0x0489}, {0x0591, 0x05A1}, {0x05A3, 0x05B9},
+               {0x05BB, 0x05BD}, {0x05BF, 0x05BF}, {0x05C1, 0x05C2},
+               {0x05C4, 0x05C4}, {0x064B, 0x0655}, {0x0670, 0x0670},
+               {0x06D6, 0x06E4}, {0x06E7, 0x06E8}, {0x06EA, 0x06ED},
+               {0x070F, 0x070F}, {0x0711, 0x0711}, {0x0730, 0x074A},
+               {0x07A6, 0x07B0}, {0x0901, 0x0902}, {0x093C, 0x093C},
+               {0x0941, 0x0948}, {0x094D, 0x094D}, {0x0951, 0x0954},
+               {0x0962, 0x0963}, {0x0981, 0x0981}, {0x09BC, 0x09BC},
+               {0x09C1, 0x09C4}, {0x09CD, 0x09CD}, {0x09E2, 0x09E3},
+               {0x0A02, 0x0A02}, {0x0A3C, 0x0A3C}, {0x0A41, 0x0A42},
+               {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A70, 0x0A71},
+               {0x0A81, 0x0A82}, {0x0ABC, 0x0ABC}, {0x0AC1, 0x0AC5},
+               {0x0AC7, 0x0AC8}, {0x0ACD, 0x0ACD}, {0x0B01, 0x0B01},
+               {0x0B3C, 0x0B3C}, {0x0B3F, 0x0B3F}, {0x0B41, 0x0B43},
+               {0x0B4D, 0x0B4D}, {0x0B56, 0x0B56}, {0x0B82, 0x0B82},
+               {0x0BC0, 0x0BC0}, {0x0BCD, 0x0BCD}, {0x0C3E, 0x0C40},
+               {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D}, {0x0C55, 0x0C56},
+               {0x0CBF, 0x0CBF}, {0x0CC6, 0x0CC6}, {0x0CCC, 0x0CCD},
+               {0x0D41, 0x0D43}, {0x0D4D, 0x0D4D}, {0x0DCA, 0x0DCA},
+               {0x0DD2, 0x0DD4}, {0x0DD6, 0x0DD6}, {0x0E31, 0x0E31},
+               {0x0E34, 0x0E3A}, {0x0E47, 0x0E4E}, {0x0EB1, 0x0EB1},
+               {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC}, {0x0EC8, 0x0ECD},
+               {0x0F18, 0x0F19}, {0x0F35, 0x0F35}, {0x0F37, 0x0F37},
+               {0x0F39, 0x0F39}, {0x0F71, 0x0F7E}, {0x0F80, 0x0F84},
+               {0x0F86, 0x0F87}, {0x0F90, 0x0F97}, {0x0F99, 0x0FBC},
+               {0x0FC6, 0x0FC6}, {0x102D, 0x1030}, {0x1032, 0x1032},
+               {0x1036, 0x1037}, {0x1039, 0x1039}, {0x1058, 0x1059},
+               {0x1160, 0x11FF}, {0x17B7, 0x17BD}, {0x17C6, 0x17C6},
+               {0x17C9, 0x17D3}, {0x180B, 0x180E}, {0x18A9, 0x18A9},
+               {0x200B, 0x200F}, {0x202A, 0x202E}, {0x206A, 0x206F},
+               {0x20D0, 0x20E3}, {0x302A, 0x302F}, {0x3099, 0x309A},
+               {0xFB1E, 0xFB1E}, {0xFE20, 0xFE23}, {0xFEFF, 0xFEFF},
+               {0xFFF9, 0xFFFB}
+       };
+ 
+       /* test for 8-bit control characters */
+       if (ucs == 0)
+               return 0;
+ 
+       if (ucs < 0x20 || (ucs >= 0x7f && ucs < 0xa0) || ucs > 0x0010ffff)
+               return -1;
+ 
+       /* binary search in table of non-spacing characters */
+       if (mbbisearch(ucs, combining,
+                                  sizeof(combining) / sizeof(struct 
mbinterval) - 1))
+               return 0;
+ 
+       /*
+        * if we arrive here, ucs is not a combining or C0/C1 control character
+        */
+ 
+       return 1 +
+               (ucs >= 0x1100 &&
+                (ucs <= 0x115f ||              /* Hangul Jamo init. consonants 
*/
+                 (ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a 
&&
+                  ucs != 0x303f) ||    /* CJK ... Yi */
+                 (ucs >= 0xac00 && ucs <= 0xd7a3) ||   /* Hangul Syllables */
+                 (ucs >= 0xf900 && ucs <= 0xfaff) ||   /* CJK Compatibility
+                                                                               
                 * Ideographs */
+                 (ucs >= 0xfe30 && ucs <= 0xfe6f) ||   /* CJK Compatibility 
Forms */
+                 (ucs >= 0xff00 && ucs <= 0xff5f) ||   /* Fullwidth Forms */
+                 (ucs >= 0xffe0 && ucs <= 0xffe6) ||
+                 (ucs >= 0x20000 && ucs <= 0x2ffff)));
+ }
+ 
+ static pg_wchar
+ utf2ucs(const unsigned char *c)
+ {
+       /*
+        * one char version of pg_utf2wchar_with_len. no control here, c must
+        * point to a large enough string
+        */
+       if ((*c & 0x80) == 0)
+               return (pg_wchar) c[0];
+       else if ((*c & 0xe0) == 0xc0)
+               return (pg_wchar) (((c[0] & 0x1f) << 6) |
+                                                  (c[1] & 0x3f));
+       else if ((*c & 0xf0) == 0xe0)
+               return (pg_wchar) (((c[0] & 0x0f) << 12) |
+                                                  ((c[1] & 0x3f) << 6) |
+                                                  (c[2] & 0x3f));
+       else if ((*c & 0xf0) == 0xf0)
+               return (pg_wchar) (((c[0] & 0x07) << 18) |
+                                                  ((c[1] & 0x3f) << 12) |
+                                                  ((c[2] & 0x3f) << 6) |
+                                                  (c[3] & 0x3f));
+       else
+               /* that is an invalid code on purpose */
+               return 0xffffffff;
+ }
+ 
  static int
  pg_utf_dsplen(const unsigned char *s)
  {
!       return ucs_wcwidth(utf2ucs(s));
  }
  
  /*
***************
*** 499,505 ****
  static int
  pg_mule_dsplen(const unsigned char *s)
  {
!       return 1;                                       /* XXX fix me! */
  }
  
  /*
--- 680,686 ----
  static int
  pg_mule_dsplen(const unsigned char *s)
  {
!       return pg_ascii_dsplen(s);                                      /* XXX 
fix me! */
  }
  
  /*
***************
*** 529,535 ****
  static int
  pg_latin1_dsplen(const unsigned char *s)
  {
!       return 1;
  }
  
  /*
--- 710,716 ----
  static int
  pg_latin1_dsplen(const unsigned char *s)
  {
!       return pg_ascii_dsplen(s);
  }
  
  /*
***************
*** 559,565 ****
        else if (IS_HIGHBIT_SET(*s))
                len = 2;        /* kanji? */
        else
!               len = 1;        /* should be ASCII */
        return len;
  }
  
--- 740,746 ----
        else if (IS_HIGHBIT_SET(*s))
                len = 2;        /* kanji? */
        else
!               len = pg_ascii_dsplen(s);       /* should be ASCII */
        return len;
  }
  
***************
*** 586,592 ****
        if (IS_HIGHBIT_SET(*s))
                len = 2;        /* kanji? */
        else
!               len = 1;        /* should be ASCII */
        return len;
  }
  
--- 767,773 ----
        if (IS_HIGHBIT_SET(*s))
                len = 2;        /* kanji? */
        else
!               len = pg_ascii_dsplen(s);       /* should be ASCII */
        return len;
  }
  
***************
*** 613,619 ****
        if (IS_HIGHBIT_SET(*s))
                len = 2;        /* kanji? */
        else
!               len = 1;        /* should be ASCII */
        return len;
  }
  
--- 794,800 ----
        if (IS_HIGHBIT_SET(*s))
                len = 2;        /* kanji? */
        else
!               len = pg_ascii_dsplen(s);       /* should be ASCII */
        return len;
  }
  
***************
*** 640,646 ****
        if (IS_HIGHBIT_SET(*s))
                len = 2;        /* 2byte? */
        else
!               len = 1;        /* should be ASCII */
        return len;
  }
  
--- 821,827 ----
        if (IS_HIGHBIT_SET(*s))
                len = 2;        /* 2byte? */
        else
!               len = pg_ascii_dsplen(s);       /* should be ASCII */
        return len;
  }
  
***************
*** 672,681 ****
  {
        int                     len;
  
!       if (!IS_HIGHBIT_SET(*s))
!               len = 1;        /* ASCII */
!       else
                len = 2;
        return len;
  }
  
--- 853,862 ----
  {
        int                     len;
  
!       if (IS_HIGHBIT_SET(*s))
                len = 2;
+       else
+               len = pg_ascii_dsplen(s);       /* ASCII */
        return len;
  }
  
Index: src/bin/psql/mbprint.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.18
diff -c -c -r1.18 mbprint.c
*** src/bin/psql/mbprint.c      15 Oct 2005 02:49:40 -0000      1.18
--- src/bin/psql/mbprint.c      10 Feb 2006 00:23:33 -0000
***************
*** 14,162 ****
  
  #include "mb/pg_wchar.h"
  
- /*
-  * This is an implementation of wcwidth() and wcswidth() as defined in
-  * "The Single UNIX Specification, Version 2, The Open Group, 1997"
-  * <http://www.UNIX-systems.org/online.html>
-  *
-  * Markus Kuhn -- 2001-09-08 -- public domain
-  *
-  * customised for PostgreSQL
-  *
-  * original available at : http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
-  */
- 
- struct mbinterval
- {
-       unsigned short first;
-       unsigned short last;
- };
- 
- /* auxiliary function for binary search in interval table */
- static int
- mbbisearch(pg_wchar ucs, const struct mbinterval * table, int max)
- {
-       int                     min = 0;
-       int                     mid;
- 
-       if (ucs < table[0].first || ucs > table[max].last)
-               return 0;
-       while (max >= min)
-       {
-               mid = (min + max) / 2;
-               if (ucs > table[mid].last)
-                       min = mid + 1;
-               else if (ucs < table[mid].first)
-                       max = mid - 1;
-               else
-                       return 1;
-       }
- 
-       return 0;
- }
- 
- 
- /* The following functions define the column width of an ISO 10646
-  * character as follows:
-  *
-  *      - The null character (U+0000) has a column width of 0.
-  *
-  *      - Other C0/C1 control characters and DEL will lead to a return
-  *            value of -1.
-  *
-  *      - Non-spacing and enclosing combining characters (general
-  *            category code Mn or Me in the Unicode database) have a
-  *            column width of 0.
-  *
-  *      - Other format characters (general category code Cf in the Unicode
-  *            database) and ZERO WIDTH SPACE (U+200B) have a column width of 
0.
-  *
-  *      - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
-  *            have a column width of 0.
-  *
-  *      - Spacing characters in the East Asian Wide (W) or East Asian
-  *            FullWidth (F) category as defined in Unicode Technical
-  *            Report #11 have a column width of 2.
-  *
-  *      - All remaining characters (including all printable
-  *            ISO 8859-1 and WGL4 characters, Unicode control characters,
-  *            etc.) have a column width of 1.
-  *
-  * This implementation assumes that wchar_t characters are encoded
-  * in ISO 10646.
-  */
- 
- static int
- ucs_wcwidth(pg_wchar ucs)
- {
-       /* sorted list of non-overlapping intervals of non-spacing characters */
-       static const struct mbinterval combining[] = {
-               {0x0300, 0x034E}, {0x0360, 0x0362}, {0x0483, 0x0486},
-               {0x0488, 0x0489}, {0x0591, 0x05A1}, {0x05A3, 0x05B9},
-               {0x05BB, 0x05BD}, {0x05BF, 0x05BF}, {0x05C1, 0x05C2},
-               {0x05C4, 0x05C4}, {0x064B, 0x0655}, {0x0670, 0x0670},
-               {0x06D6, 0x06E4}, {0x06E7, 0x06E8}, {0x06EA, 0x06ED},
-               {0x070F, 0x070F}, {0x0711, 0x0711}, {0x0730, 0x074A},
-               {0x07A6, 0x07B0}, {0x0901, 0x0902}, {0x093C, 0x093C},
-               {0x0941, 0x0948}, {0x094D, 0x094D}, {0x0951, 0x0954},
-               {0x0962, 0x0963}, {0x0981, 0x0981}, {0x09BC, 0x09BC},
-               {0x09C1, 0x09C4}, {0x09CD, 0x09CD}, {0x09E2, 0x09E3},
-               {0x0A02, 0x0A02}, {0x0A3C, 0x0A3C}, {0x0A41, 0x0A42},
-               {0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A70, 0x0A71},
-               {0x0A81, 0x0A82}, {0x0ABC, 0x0ABC}, {0x0AC1, 0x0AC5},
-               {0x0AC7, 0x0AC8}, {0x0ACD, 0x0ACD}, {0x0B01, 0x0B01},
-               {0x0B3C, 0x0B3C}, {0x0B3F, 0x0B3F}, {0x0B41, 0x0B43},
-               {0x0B4D, 0x0B4D}, {0x0B56, 0x0B56}, {0x0B82, 0x0B82},
-               {0x0BC0, 0x0BC0}, {0x0BCD, 0x0BCD}, {0x0C3E, 0x0C40},
-               {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D}, {0x0C55, 0x0C56},
-               {0x0CBF, 0x0CBF}, {0x0CC6, 0x0CC6}, {0x0CCC, 0x0CCD},
-               {0x0D41, 0x0D43}, {0x0D4D, 0x0D4D}, {0x0DCA, 0x0DCA},
-               {0x0DD2, 0x0DD4}, {0x0DD6, 0x0DD6}, {0x0E31, 0x0E31},
-               {0x0E34, 0x0E3A}, {0x0E47, 0x0E4E}, {0x0EB1, 0x0EB1},
-               {0x0EB4, 0x0EB9}, {0x0EBB, 0x0EBC}, {0x0EC8, 0x0ECD},
-               {0x0F18, 0x0F19}, {0x0F35, 0x0F35}, {0x0F37, 0x0F37},
-               {0x0F39, 0x0F39}, {0x0F71, 0x0F7E}, {0x0F80, 0x0F84},
-               {0x0F86, 0x0F87}, {0x0F90, 0x0F97}, {0x0F99, 0x0FBC},
-               {0x0FC6, 0x0FC6}, {0x102D, 0x1030}, {0x1032, 0x1032},
-               {0x1036, 0x1037}, {0x1039, 0x1039}, {0x1058, 0x1059},
-               {0x1160, 0x11FF}, {0x17B7, 0x17BD}, {0x17C6, 0x17C6},
-               {0x17C9, 0x17D3}, {0x180B, 0x180E}, {0x18A9, 0x18A9},
-               {0x200B, 0x200F}, {0x202A, 0x202E}, {0x206A, 0x206F},
-               {0x20D0, 0x20E3}, {0x302A, 0x302F}, {0x3099, 0x309A},
-               {0xFB1E, 0xFB1E}, {0xFE20, 0xFE23}, {0xFEFF, 0xFEFF},
-               {0xFFF9, 0xFFFB}
-       };
- 
-       /* test for 8-bit control characters */
-       if (ucs == 0)
-               return 0;
- 
-       if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0) || ucs > 0x0010ffff)
-               return -1;
- 
-       /* binary search in table of non-spacing characters */
-       if (mbbisearch(ucs, combining,
-                                  sizeof(combining) / sizeof(struct 
mbinterval) - 1))
-               return 0;
- 
-       /*
-        * if we arrive here, ucs is not a combining or C0/C1 control character
-        */
- 
-       return 1 +
-               (ucs >= 0x1100 &&
-                (ucs <= 0x115f ||              /* Hangul Jamo init. consonants 
*/
-                 (ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a 
&&
-                  ucs != 0x303f) ||    /* CJK ... Yi */
-                 (ucs >= 0xac00 && ucs <= 0xd7a3) ||   /* Hangul Syllables */
-                 (ucs >= 0xf900 && ucs <= 0xfaff) ||   /* CJK Compatibility
-                                                                               
                 * Ideographs */
-                 (ucs >= 0xfe30 && ucs <= 0xfe6f) ||   /* CJK Compatibility 
Forms */
-                 (ucs >= 0xff00 && ucs <= 0xff5f) ||   /* Fullwidth Forms */
-                 (ucs >= 0xffe0 && ucs <= 0xffe6) ||
-                 (ucs >= 0x20000 && ucs <= 0x2ffff)));
- }
- 
  static pg_wchar
  utf2ucs(const unsigned char *c)
  {
--- 14,19 ----
***************
*** 191,225 ****
        }
  }
  
- /* mb_utf_wcwidth : calculate column length for the utf8 string pwcs
-  */
- static int
- mb_utf_wcswidth(const unsigned char *pwcs, size_t len)
- {
-       int                     w,
-                               l = 0;
-       int                     width = 0;
- 
-       for (; *pwcs && len > 0; pwcs += l)
-       {
-               l = pg_utf_mblen(pwcs);
-               if ((len < (size_t) l) || ((w = ucs_wcwidth(utf2ucs(pwcs))) < 
0))
-                       return width;
-               len -= l;
-               width += w;
-       }
-       return width;
- }
  
  static int
  utf_charcheck(const unsigned char *c)
  {
-       /*
-        * Unicode 3.1 compliant validation : for each category, it checks the
-        * combination of each byte to make sur it maps to a valid range. It 
also
-        * returns -1 for the following UCS values: ucs > 0x10ffff ucs & 0xfffe 
=
-        * 0xfffe 0xfdd0 < ucs < 0xfdef ucs & 0xdb00 = 0xd800 (surrogates)
-        */
        if ((*c & 0x80) == 0)
                return 1;
        else if ((*c & 0xe0) == 0xc0)
--- 48,63 ----
        }
  }
  
  
+ /*
+  * Unicode 3.1 compliant validation : for each category, it checks the
+  * combination of each byte to make sure it maps to a valid range. It also
+  * returns -1 for the following UCS values: ucs > 0x10ffff ucs & 0xfffe =
+  * 0xfffe 0xfdd0 < ucs < 0xfdef ucs & 0xdb00 = 0xd800 (surrogates)
+  */
  static int
  utf_charcheck(const unsigned char *c)
  {
        if ((*c & 0x80) == 0)
                return 1;
        else if ((*c & 0xe0) == 0xc0)
***************
*** 270,275 ****
--- 108,114 ----
        return -1;
  }
  
+ 
  static void
  mb_utf_validate(unsigned char *pwcs)
  {
***************
*** 277,304 ****
  
        while (*pwcs)
        {
!               int                     l;
  
!               if ((l = utf_charcheck(pwcs)) > 0)
                {
                        if (p != pwcs)
                        {
                                int                     i;
  
!                               for (i = 0; i < l; i++)
                                        *p++ = *pwcs++;
                        }
                        else
                        {
!                               pwcs += l;
!                               p += l;
                        }
                }
                else
-               {
                        /* we skip the char */
                        pwcs++;
-               }
        }
        if (p != pwcs)
                *p = '\0';
--- 116,141 ----
  
        while (*pwcs)
        {
!               int                     len;
  
!               if ((len = utf_charcheck(pwcs)) > 0)
                {
                        if (p != pwcs)
                        {
                                int                     i;
  
!                               for (i = 0; i < len; i++)
                                        *p++ = *pwcs++;
                        }
                        else
                        {
!                               pwcs += len;
!                               p += len;
                        }
                }
                else
                        /* we skip the char */
                        pwcs++;
        }
        if (p != pwcs)
                *p = '\0';
***************
*** 308,330 ****
   * public functions : wcswidth and mbvalidate
   */
  
  int
! pg_wcswidth(const char *pwcs, size_t len, int encoding)
  {
!       if (encoding == PG_UTF8)
!               return mb_utf_wcswidth((const unsigned char *) pwcs, len);
!       else
        {
!               /*
!                * obviously, other encodings may want to fix this, but I don't 
know
!                * them myself, unfortunately.
!                */
!               return len;
        }
  }
  
! char *
! mbvalidate(char *pwcs, int encoding)
  {
        if (encoding == PG_UTF8)
                mb_utf_validate((unsigned char *) pwcs);
--- 145,337 ----
   * public functions : wcswidth and mbvalidate
   */
  
+ /*
+  * pg_wcswidth is the dumb width function. It assumes that everything will
+  * only appear on one line. OTOH it is easier to use if this applies to you.
+  */
  int
! pg_wcswidth(const unsigned char *pwcs, size_t len, int encoding)
  {
!       int width = 0;
! 
!       while (len > 0)
        {
!               int chlen, chwidth;
! 
!               chlen = PQmblen(pwcs, encoding);
!               if (chlen > len)
!                       break;     /* Invalid string */
!                       
!               chwidth = PQdsplen(pwcs, encoding);
!               
!               if (chwidth > 0)
!                       width += chwidth;
!               pwcs += chlen;
!       }
!       return width;
! }
! 
! /*
!  * pg_wcssize takes the given string in the given encoding and returns three
!  * values:
!  *    result_width: Width in display character of longest line in string
!  *    result_hieght: Number of lines in display output
!  *    result_format_size: Number of bytes required to store formatted 
representation of string
!  */
! int
! pg_wcssize(unsigned char *pwcs, size_t len, int encoding, int *result_width,
!                       int *result_height, int *result_format_size)
! {
!       int     w,
!               chlen = 0,
!               linewidth = 0;
!       int width = 0;
!       int height = 1;
!       int format_size = 0;
! 
!       for (; *pwcs && len > 0; pwcs += chlen)
!       {
!               chlen = PQmblen(pwcs, encoding);
!               if (len < (size_t)chlen)
!                       break;
!               w = PQdsplen(pwcs, encoding);
! 
!               if (chlen == 1)   /* ASCII char */
!               {
!                       if (*pwcs == '\n') /* Newline */
!                       {
!                               if (linewidth > width)
!                                       width = linewidth;
!                               linewidth = 0;
!                               height += 1;
!                               format_size += 1;  /* For NUL char */
!                       }
!                       else if (*pwcs == '\r')   /* Linefeed */
!                       {
!                               linewidth += 2;
!                               format_size += 2;
!                       }
!                       else if (w <= 0)  /* Other control char */
!                       {
!                               linewidth += 4;
!                               format_size += 4;
!                       }
!                       else  /* Output itself */
!                       {
!                               linewidth++;
!                               format_size += 1;
!                       }
!               }
!               else if (w <= 0)  /* Non-ascii control char */
!               {
!                       linewidth += 6;   /* \u0000 */
!                       format_size += 6;
!               }
!               else  /* All other chars */
!               {
!                       linewidth += w;
!                       format_size += chlen;
!               }
!               len -= chlen;
!       }
!       if (linewidth > width)
!               width = linewidth;
!       format_size += 1;
!       
!       /* Set results */
!       if (result_width)
!               *result_width = width;
!       if (result_height)
!               *result_height = height;
!       if (result_format_size)
!               *result_format_size = format_size;
!               
!       return width;
! }
! 
! void
! pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
!                        struct lineptr *lines, int count)
! {
!       int                     w,
!                               chlen = 0;
!       int linewidth = 0;
!       
!       char *ptr = lines->ptr;   /* Pointer to data area */
! 
!       for (; *pwcs && len > 0; pwcs += chlen)
!       {
!               chlen = PQmblen(pwcs,encoding);
!               if (len < (size_t)chlen)
!                       break;
!               w = PQdsplen(pwcs,encoding);
! 
!               if (chlen == 1)   /* single byte char char */
!               {
!                       if (*pwcs == '\n') /* Newline */
!                       {
!                               *ptr++ = 0;   /* NULL char */
!                               lines->width = linewidth;
!                               linewidth = 0;
!                               lines++;
!                               count--;
!                               if (count == 0)
!                                       exit(1);   /* Screwup */        
!                                       
!                               lines->ptr = ptr;
!                       }
!                       else if (*pwcs == '\r')   /* Linefeed */
!                       {
!                               strcpy(ptr, "\\r");
!                               linewidth += 2;
!                               ptr += 2;
!                       }
!                       else if (w <= 0)  /* Other control char */
!                       {
!                               sprintf(ptr, "\\x%02X", *pwcs);
!                               linewidth += 4;
!                               ptr += 4;
!                       }
!                       else  /* Output itself */
!                       {
!                               linewidth++;
!                               *ptr++ = *pwcs;
!                       }
!               }
!               else if (w <= 0)  /* Non-ascii control char */
!               {
!                       if (encoding == PG_UTF8)
!                               sprintf(ptr, "\\u%04X", utf2ucs(pwcs));
!                       else
!                               /* This case cannot happen in the current
!                                * code because only UTF-8 signals multibyte
!                                * control characters. But we may need to
!                                * support it at some stage */
!                               sprintf(ptr, "\\u????");
!                               
!                       ptr += 6;
!                       linewidth += 6;
!               }
!               else  /* All other chars */
!               {
!                       int i;
!                       for (i=0; i < chlen; i++)
!                               *ptr++ = pwcs[i];
!                       linewidth += w;
!               }
!               len -= chlen;
        }
+       *ptr++ = 0;
+       lines->width = linewidth;
+       lines++;
+       count--;
+       if (count > 0)
+               lines->ptr = NULL;
+       return;
  }
  
! unsigned char *
! mbvalidate(unsigned char *pwcs, int encoding)
  {
        if (encoding == PG_UTF8)
                mb_utf_validate((unsigned char *) pwcs);
Index: src/bin/psql/mbprint.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.h,v
retrieving revision 1.8
diff -c -c -r1.8 mbprint.h
*** src/bin/psql/mbprint.h      24 Sep 2005 17:53:27 -0000      1.8
--- src/bin/psql/mbprint.h      10 Feb 2006 00:23:33 -0000
***************
*** 4,11 ****
  
  #include "mb/pg_wchar.h"
  
! extern char *mbvalidate(char *pwcs, int encoding);
  
! extern int    pg_wcswidth(const char *pwcs, size_t len, int encoding);
  
  #endif   /* MBPRINT_H */
--- 4,18 ----
  
  #include "mb/pg_wchar.h"
  
! struct lineptr {
!       unsigned char *ptr;
!       int width;
! };
  
! extern unsigned char *mbvalidate(unsigned char *pwcs, int encoding);
! 
! extern int    pg_wcswidth(const unsigned char *pwcs, size_t len, int 
encoding);
! extern void   pg_wcsformat(unsigned char *pwcs, size_t len, int encoding, 
struct lineptr *lines, int count);
! extern int    pg_wcssize(unsigned char *pwcs, size_t len, int encoding, int 
*width, int *height, int *format_size);
  
  #endif   /* MBPRINT_H */
Index: src/bin/psql/print.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.79
diff -c -c -r1.79 print.c
*** src/bin/psql/print.c        27 Oct 2005 13:34:47 -0000      1.79
--- src/bin/psql/print.c        10 Feb 2006 00:23:33 -0000
***************
*** 49,54 ****
--- 49,68 ----
        return tmp;
  }
  
+ static void *
+ pg_local_calloc(int count, size_t size)
+ {
+       void       *tmp;
+ 
+       tmp = calloc(count, size);
+       if (!tmp)
+       {
+               fprintf(stderr, _("out of memory\n"));
+               exit(EXIT_FAILURE);
+       }
+       return tmp;
+ }
+ 
  static int
  integer_digits(const char *my_str)
  {
***************
*** 87,92 ****
--- 101,107 ----
        return strlen(my_str) + additional_numeric_locale_len(my_str);
  }
  
+ /* Returns the appropriately formatted string in a new allocated block, 
caller must free */
  static char *
  format_numeric_locale(const char *my_str)
  {
***************
*** 342,354 ****
  {
        unsigned int col_count = 0;
        unsigned int cell_count = 0;
-       unsigned int *head_w,
-                          *cell_w;
        unsigned int i,
                                tmp;
        unsigned int *widths,
                                total_w;
!       const char *const * ptr;
  
        /* count columns */
        for (ptr = headers; *ptr; ptr++)
--- 357,376 ----
  {
        unsigned int col_count = 0;
        unsigned int cell_count = 0;
        unsigned int i,
                                tmp;
        unsigned int *widths,
                                total_w;
!       unsigned int *heights;
!       unsigned int *format_space;
!       unsigned char **format_buf;
!       
!       const char *const *ptr;
!       
!       struct lineptr **col_lineptrs;   /* pointers to line pointer for each 
column */
!       struct lineptr *lineptr_list;    /* complete list of linepointers */
!       
!       int *complete;                  /* Array remembering which columns have 
completed output */
  
        /* count columns */
        for (ptr = headers; *ptr; ptr++)
***************
*** 356,419 ****
  
        if (col_count > 0)
        {
!               widths = calloc(col_count, sizeof(*widths));
!               if (!widths)
!               {
!                       fprintf(stderr, _("out of memory\n"));
!                       exit(EXIT_FAILURE);
!               }
! 
!               head_w = calloc(col_count, sizeof(*head_w));
!               if (!head_w)
!               {
!                       fprintf(stderr, _("out of memory\n"));
!                       exit(EXIT_FAILURE);
!               }
        }
        else
        {
                widths = NULL;
!               head_w = NULL;
        }
! 
        /* count cells (rows * cols) */
        for (ptr = cells; *ptr; ptr++)
                cell_count++;
  
-       if (cell_count > 0)
-       {
-               cell_w = calloc(cell_count, sizeof(*cell_w));
-               if (!cell_w)
-               {
-                       fprintf(stderr, _("out of memory\n"));
-                       exit(EXIT_FAILURE);
-               }
-       }
-       else
-               cell_w = NULL;
- 
        /* calc column widths */
        for (i = 0; i < col_count; i++)
        {
!               tmp = pg_wcswidth(headers[i], strlen(headers[i]), encoding);
                if (tmp > widths[i])
                        widths[i] = tmp;
!               head_w[i] = tmp;
        }
  
        for (i = 0, ptr = cells; *ptr; ptr++, i++)
        {
!               int                     add_numeric_locale_len;
  
                if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
!                       add_numeric_locale_len = 
additional_numeric_locale_len(*ptr);
!               else
!                       add_numeric_locale_len = 0;
! 
!               tmp = pg_wcswidth(*ptr, strlen(*ptr), encoding) + 
add_numeric_locale_len;
                if (tmp > widths[i % col_count])
                        widths[i % col_count] = tmp;
!               cell_w[i] = tmp;
        }
  
        if (opt_border == 0)
--- 378,438 ----
  
        if (col_count > 0)
        {
!               widths = pg_local_calloc(col_count, sizeof(*widths));
!               heights = pg_local_calloc(col_count, sizeof(*heights));
!               col_lineptrs = pg_local_calloc(col_count, 
sizeof(*col_lineptrs));
!               format_space = pg_local_calloc(col_count, 
sizeof(*format_space));
!               format_buf = pg_local_calloc(col_count, sizeof(*format_buf));
!               complete = pg_local_calloc(col_count, sizeof(*complete));
!       
        }
        else
        {
                widths = NULL;
!               heights = NULL;
!               col_lineptrs = NULL;
!               format_space = NULL;
!               format_buf = NULL;
!               complete = NULL;
        }
!       
        /* count cells (rows * cols) */
        for (ptr = cells; *ptr; ptr++)
                cell_count++;
  
        /* calc column widths */
        for (i = 0; i < col_count; i++)
        {
!               /* Get width & height */
!               int height, space;
!               pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), 
encoding, &tmp, &height, &space);
                if (tmp > widths[i])
                        widths[i] = tmp;
!               if (height > heights[i])
!                       heights[i] = height;
!               if (space > format_space[i])
!                       format_space[i] = space;
        }
  
        for (i = 0, ptr = cells; *ptr; ptr++, i++)
        {
!               int numeric_locale_len;
!               int height, space;
  
                if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
!                       numeric_locale_len = 
additional_numeric_locale_len(*ptr);
!               else 
!                       numeric_locale_len = 0;
!               
!               /* Get width, ignore height */
!               pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, 
&tmp, &height, &space);
!               tmp += numeric_locale_len;
                if (tmp > widths[i % col_count])
                        widths[i % col_count] = tmp;
!               if (height > heights[i % col_count])
!                       heights[i % col_count] = height;
!               if (space > format_space[i % col_count])
!                       format_space[i % col_count] = space;
        }
  
        if (opt_border == 0)
***************
*** 426,435 ****
        for (i = 0; i < col_count; i++)
                total_w += widths[i];
  
        /* print title */
        if (title && !opt_tuples_only)
        {
!               tmp = pg_wcswidth(title, strlen(title), encoding);
                if (tmp >= total_w)
                        fprintf(fout, "%s\n", title);
                else
--- 445,482 ----
        for (i = 0; i < col_count; i++)
                total_w += widths[i];
  
+       /* At this point:
+        *  widths contains the max width of each column
+        *  heights contains the max height of a cell of each column
+        *  format_space contains maximum space required to store formatted 
string
+        * so we prepare the formatting structures
+        */
+       {
+               int heights_total = 0;
+               struct lineptr *lineptr;
+               
+               for (i = 0; i < col_count; i++)
+                       heights_total += heights[i];
+                       
+               lineptr = lineptr_list = pg_local_calloc(heights_total, 
sizeof(*lineptr_list));
+                       
+               for (i = 0; i < col_count; i++)
+               {
+                       col_lineptrs[i] = lineptr;
+                       lineptr += heights[i];
+                       
+                       format_buf[i] = pg_local_malloc(format_space[i]);
+                       
+                       col_lineptrs[i]->ptr = format_buf[i];
+               }
+       }
+                       
        /* print title */
        if (title && !opt_tuples_only)
        {
!               /* Get width & height */
!               int height;
!               pg_wcssize((unsigned char *)title, strlen(title), encoding, 
&tmp, &height, NULL);
                if (tmp >= total_w)
                        fprintf(fout, "%s\n", title);
                else
***************
*** 439,528 ****
        /* print headers */
        if (!opt_tuples_only)
        {
                if (opt_border == 2)
                        _print_horizontal_line(col_count, widths, opt_border, 
fout);
  
-               if (opt_border == 2)
-                       fputs("| ", fout);
-               else if (opt_border == 1)
-                       fputc(' ', fout);
- 
                for (i = 0; i < col_count; i++)
                {
!                       unsigned int nbspace;
  
!                       nbspace = widths[i] - head_w[i];
  
!                       /* centered */
!                       fprintf(fout, "%-*s%s%-*s",
!                                       nbspace / 2, "", headers[i], (nbspace + 
1) / 2, "");
  
!                       if (i < col_count - 1)
!                       {
!                               if (opt_border == 0)
!                                       fputc(' ', fout);
                                else
!                                       fputs(" | ", fout);
                        }
                }
  
-               if (opt_border == 2)
-                       fputs(" |", fout);
-               else if (opt_border == 1)
-                       fputc(' ', fout);;
-               fputc('\n', fout);
  
                _print_horizontal_line(col_count, widths, opt_border, fout);
        }
  
        /* print cells */
!       for (i = 0, ptr = cells; *ptr; i++, ptr++)
        {
!               /* beginning of line */
!               if (i % col_count == 0)
                {
                        if (opt_border == 2)
                                fputs("| ", fout);
                        else if (opt_border == 1)
                                fputc(' ', fout);
-               }
  
!               /* content */
!               if (opt_align[i % col_count] == 'r')
!               {
!                       if (opt_numeric_locale)
                        {
!                               char       *my_cell = 
format_numeric_locale(*ptr);
  
!                               fprintf(fout, "%*s%s", widths[i % col_count] - 
cell_w[i], "", my_cell);
!                               free(my_cell);
                        }
-                       else
-                               fprintf(fout, "%*s%s", widths[i % col_count] - 
cell_w[i], "", *ptr);
-               }
-               else
-               {
-                       if ((i + 1) % col_count == 0 && opt_border != 2)
-                               fputs(cells[i], fout);
-                       else
-                               fprintf(fout, "%-s%*s", cells[i],
-                                               widths[i % col_count] - 
cell_w[i], "");
-               }
- 
-               /* divider */
-               if ((i + 1) % col_count)
-               {
-                       if (opt_border == 0)
-                               fputc(' ', fout);
-                       else
-                               fputs(" | ", fout);
-               }
-               /* end of line */
-               else
-               {
                        if (opt_border == 2)
                                fputs(" |", fout);
                        fputc('\n', fout);
                }
        }
  
--- 486,623 ----
        /* print headers */
        if (!opt_tuples_only)
        {
+               int cols_todo;
+               int line_count;
+               
                if (opt_border == 2)
                        _print_horizontal_line(col_count, widths, opt_border, 
fout);
  
                for (i = 0; i < col_count; i++)
+                       pg_wcsformat((unsigned char *)headers[i], 
strlen(headers[i]), encoding, col_lineptrs[i], heights[i]);
+       
+               cols_todo = col_count;
+               line_count = 0;
+               memset(complete, 0, col_count*sizeof(int));
+               while (cols_todo)
                {
!                       if (opt_border == 2)
!                               fprintf(fout, "|%c", line_count ? '+' : ' ');
!                       else if (opt_border == 1)
!                               fputc(line_count ? '+' : ' ', fout);
  
!                       for (i = 0; i < col_count; i++)
!                       {
!                               unsigned int nbspace;
  
!                               struct lineptr *this_line = col_lineptrs[i] + 
line_count;
!                               if (!complete[i])
!                               {
!                                       nbspace = widths[i] - this_line->width;
  
!                                       /* centered */
!                                       fprintf(fout, "%-*s%s%-*s",
!                                                       nbspace / 2, "", 
this_line->ptr, (nbspace + 1) / 2, "");
! 
!                                       if (line_count == (heights[i]-1) || 
!(this_line+1)->ptr)
!                                       {
!                                               cols_todo--;
!                                               complete[i] = 1;
!                                       }
!                               }
                                else
!                                       fprintf(fout, "%*s", widths[i], "");
!                               if (i < col_count - 1)
!                               {
!                                       if (opt_border == 0)
!                                               fputc(line_count ? '+' : ' ', 
fout);
!                                       else
!                                               fprintf(fout, " |%c", 
line_count ? '+' : ' ');
!                               }
                        }
+                       line_count++;
+ 
+                       if (opt_border == 2)
+                               fputs(" |", fout);
+                       else if (opt_border == 1)
+                               fputc(' ', fout);;
+                       fputc('\n', fout);
                }
  
  
                _print_horizontal_line(col_count, widths, opt_border, fout);
        }
  
        /* print cells */
!       for (i = 0, ptr = cells; *ptr; i+=col_count, ptr+=col_count)
        {
!               int j;
!               int cols_todo = col_count;
!               int line_count;                 /* Number of lines output so 
far in row */
!               
!               for (j = 0; j < col_count; j++)
!                       pg_wcsformat((unsigned char*)ptr[j], strlen(ptr[j]), 
encoding, col_lineptrs[j], heights[j]);
!       
!               line_count = 0;
!               memset(complete, 0, col_count*sizeof(int));
!               while (cols_todo)
                {
+                       /* beginning of line */
                        if (opt_border == 2)
                                fputs("| ", fout);
                        else if (opt_border == 1)
                                fputc(' ', fout);
  
!                       for (j = 0; j < col_count; j++)
                        {
!                               struct lineptr *this_line = col_lineptrs[j] + 
line_count;
!                               if (complete[j])  /* Just print spaces... */
!                                       fprintf(fout, "%*s", widths[j], "");
!                               else
!                               {
  
!                                       /* content */
!                                       if (opt_align[j] == 'r')
!                                       {
!                                               if (opt_numeric_locale)
!                                               {
!                                                       /* Assumption: This 
code used only on strings
!                                                        * without multibyte 
characters, otherwise
!                                                        * this_line->width < 
strlen(this_ptr) and we
!                                                        * get an overflow */
! 
!                                                       char *my_cell = 
format_numeric_locale(this_line->ptr);
!                                                       fprintf(fout, "%*s%s", 
widths[i % col_count] - strlen(my_cell), "", my_cell);
!                                                       free(my_cell);
!                                               }
!                                               else
!                                                       fprintf(fout, "%*s%s", 
widths[j] - this_line->width, "", this_line->ptr);
!                                       }
!                                       else
!                                               fprintf(fout, "%-s%*s", 
this_line->ptr,
!                                                               widths[j] - 
this_line->width, "");
!                                       /* If at the right height, done this 
col */
!                                       if (line_count == heights[j]-1 || 
!this_line[1].ptr)
!                                       {
!                                               complete[j] = 1;
!                                               cols_todo--;
!                                       }
!                               }
!       
!                               /* divider */
!                               if ((j + 1) % col_count)
!                               {
!                                       if (opt_border == 0)
!                                               fputc(' ', fout);
!                                       else if (line_count == 0)
!                                               fputs(" | ", fout);
!                                       else
!                                               fprintf(fout, " %c ", 
complete[j+1] ? ' ' : ':');
!                               }
                        }
                        if (opt_border == 2)
                                fputs(" |", fout);
                        fputc('\n', fout);
+                       line_count++;
                }
        }
  
***************
*** 543,551 ****
  #endif
  
        /* clean up */
-       free(cell_w);
-       free(head_w);
        free(widths);
  }
  
  
--- 638,652 ----
  #endif
  
        /* clean up */
        free(widths);
+       free(heights);
+       free(col_lineptrs);
+       free(format_space);
+       free(complete);
+       free(lineptr_list);
+       for (i= 0; i < col_count; i++)
+               free(format_buf[i]);
+       free(format_buf);
  }
  
  
***************
*** 563,574 ****
        unsigned int i,
                                tmp = 0,
                                hwidth = 0,
!                               dwidth = 0;
        char       *divider;
        unsigned int cell_count = 0;
!       unsigned int *cell_w,
!                          *head_w;
! 
        if (cells[0] == NULL)
        {
                fprintf(fout, _("(No rows)\n"));
--- 664,678 ----
        unsigned int i,
                                tmp = 0,
                                hwidth = 0,
!                               dwidth = 0,
!                               hheight = 1,
!                               dheight = 1,
!                               hformatsize = 0,
!                               dformatsize = 0;
        char       *divider;
        unsigned int cell_count = 0;
!       struct lineptr *hlineptr, *dlineptr;
!       
        if (cells[0] == NULL)
        {
                fprintf(fout, _("(No rows)\n"));
***************
*** 578,635 ****
        /* count headers and find longest one */
        for (ptr = headers; *ptr; ptr++)
                col_count++;
-       if (col_count > 0)
-       {
-               head_w = calloc(col_count, sizeof(*head_w));
-               if (!head_w)
-               {
-                       fprintf(stderr, _("out of memory\n"));
-                       exit(EXIT_FAILURE);
-               }
-       }
-       else
-               head_w = NULL;
  
        for (i = 0; i < col_count; i++)
        {
!               tmp = pg_wcswidth(headers[i], strlen(headers[i]), encoding);
                if (tmp > hwidth)
                        hwidth = tmp;
!               head_w[i] = tmp;
        }
  
        /* Count cells, find their lengths */
        for (ptr = cells; *ptr; ptr++)
                cell_count++;
  
-       if (cell_count > 0)
-       {
-               cell_w = calloc(cell_count, sizeof(*cell_w));
-               if (!cell_w)
-               {
-                       fprintf(stderr, _("out of memory\n"));
-                       exit(EXIT_FAILURE);
-               }
-       }
-       else
-               cell_w = NULL;
- 
        /* find longest data cell */
        for (i = 0, ptr = cells; *ptr; ptr++, i++)
        {
!               int                     add_numeric_locale_len;
  
                if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
!                       add_numeric_locale_len = 
additional_numeric_locale_len(*ptr);
!               else
!                       add_numeric_locale_len = 0;
  
!               tmp = pg_wcswidth(*ptr, strlen(*ptr), encoding) + 
add_numeric_locale_len;
                if (tmp > dwidth)
                        dwidth = tmp;
!               cell_w[i] = tmp;
!       }
! 
        /* print title */
        if (!opt_tuples_only && title)
                fprintf(fout, "%s\n", title);
--- 682,733 ----
        /* count headers and find longest one */
        for (ptr = headers; *ptr; ptr++)
                col_count++;
  
+       /* Find the maximum dimensions for the headers */
        for (i = 0; i < col_count; i++)
        {
!               int height, fs;
!               pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), 
encoding, &tmp, &height, &fs);
                if (tmp > hwidth)
                        hwidth = tmp;
!               if (height > hheight)
!                       hheight = height;
!               if (fs > hformatsize)
!                       hformatsize = fs;
        }
  
        /* Count cells, find their lengths */
        for (ptr = cells; *ptr; ptr++)
                cell_count++;
  
        /* find longest data cell */
        for (i = 0, ptr = cells; *ptr; ptr++, i++)
        {
!               int numeric_locale_len;
!               int height, fs;
  
                if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
!                       numeric_locale_len = 
additional_numeric_locale_len(*ptr);
!               else 
!                       numeric_locale_len = 0;
  
!               pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, 
&tmp, &height, &fs);
!               tmp += numeric_locale_len;
                if (tmp > dwidth)
                        dwidth = tmp;
!               if (height > dheight)
!                       dheight = height;
!               if (fs > dformatsize)
!                       dformatsize = fs;
!       }
!       
!       /* We now have all the information we need to setup the formatting 
structures */
!       dlineptr = pg_local_malloc(sizeof(*dlineptr) * dheight);
!       hlineptr = pg_local_malloc(sizeof(*hlineptr) * hheight);
!       
!       dlineptr->ptr = pg_local_malloc(dformatsize);
!       hlineptr->ptr = pg_local_malloc(hformatsize);
!       
        /* print title */
        if (!opt_tuples_only && title)
                fprintf(fout, "%s\n", title);
***************
*** 653,658 ****
--- 751,758 ----
        /* print records */
        for (i = 0, ptr = cells; *ptr; i++, ptr++)
        {
+               int line_count, dcomplete, hcomplete;
+               
                if (i % col_count == 0)
                {
                        if (!opt_tuples_only)
***************
*** 688,720 ****
                                fprintf(fout, "%s\n", divider);
                }
  
!               if (opt_border == 2)
!                       fputs("| ", fout);
!               fprintf(fout, "%-s%*s", headers[i % col_count],
!                               hwidth - head_w[i % col_count], "");
! 
!               if (opt_border > 0)
!                       fputs(" | ", fout);
!               else
!                       fputs(" ", fout);
! 
!               if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
                {
!                       char       *my_cell = format_numeric_locale(*ptr);
! 
!                       if (opt_border < 2)
!                               fprintf(fout, "%s\n", my_cell);
                        else
!                               fprintf(fout, "%-s%*s |\n", my_cell, dwidth - 
cell_w[i], "");
!                       free(my_cell);
!               }
!               else
!               {
!                       if (opt_border < 2)
!                               fprintf(fout, "%s\n", *ptr);
                        else
!                               fprintf(fout, "%-s%*s |\n", *ptr, dwidth - 
cell_w[i], "");
!               }
        }
  
        if (opt_border == 2)
--- 788,853 ----
                                fprintf(fout, "%s\n", divider);
                }
  
!               /* Format the header */
!               pg_wcsformat((unsigned char*)headers[i % col_count],
!                                        strlen(headers[i % col_count]), 
encoding, hlineptr, hheight);
!               /* Format the data */
!               pg_wcsformat((unsigned char*)*ptr, strlen(*ptr), encoding, 
dlineptr, dheight);
!               
!               line_count = 0;
!               dcomplete = hcomplete = 0;
!               while (!dcomplete || !hcomplete)
                {
!                       if (opt_border == 2)
!                               fputs("| ", fout);
!                       if (!hcomplete)
!                       {
!                               fprintf(fout, "%-s%*s", 
hlineptr[line_count].ptr,
!                                               hwidth - 
hlineptr[line_count].width, "");
!                                               
!                               if (line_count == (hheight-1) || 
!hlineptr[line_count+1].ptr)
!                                       hcomplete = 1;
!                       }
                        else
!                               fprintf(fout, "%*s", hwidth, "");
!       
!                       if (opt_border > 0)
!                               fprintf(fout, " %c ", (line_count==0)?'|':':');
                        else
!                               fputs(" ", fout);
! 
!                       if (!dcomplete)
!                       {
!                               if (opt_align[i % col_count] == 'r' && 
opt_numeric_locale)
!                               {
!                                       char *my_cell = 
format_numeric_locale(dlineptr[line_count].ptr);
!                                       if (opt_border < 2)
!                                               fprintf(fout, "%s\n", my_cell);
!                                       else
!                                               fprintf(fout, "%-s%*s |\n", 
my_cell, dwidth - strlen(my_cell), "");
!                                       free(my_cell);
!                               }
!                               else
!                               {
!                                       if (opt_border < 2)
!                                               fprintf(fout, "%s\n", 
dlineptr[line_count].ptr);
!                                       else
!                                               fprintf(fout, "%-s%*s |\n", 
dlineptr[line_count].ptr,
!                                                               dwidth - 
dlineptr[line_count].width, "");
!                               }
!                               
!                               if (line_count == dheight - 1 || 
!dlineptr[line_count+1].ptr)
!                                       dcomplete = 1;
!                       }
!                       else
!                       {
!                               if (opt_border < 2)
!                                       fputc('\n', fout);
!                               else
!                                       fprintf(fout, "%*s |\n", dwidth, "");
!                       }
!                       line_count++;
!               }
        }
  
        if (opt_border == 2)
***************
*** 732,740 ****
  
        fputc('\n', fout);
        free(divider);
! 
!       free(cell_w);
!       free(head_w);
  }
  
  
--- 865,874 ----
  
        fputc('\n', fout);
        free(divider);
!       free(hlineptr->ptr);
!       free(dlineptr->ptr);
!       free(hlineptr);
!       free(dlineptr);
  }
  
  
***************
*** 1613,1636 ****
        /* extract headers */
        nfields = PQnfields(result);
  
!       headers = calloc(nfields + 1, sizeof(*headers));
!       if (!headers)
!       {
!               fprintf(stderr, _("out of memory\n"));
!               exit(EXIT_FAILURE);
!       }
  
        for (i = 0; i < nfields; i++)
                headers[i] = mbvalidate(PQfname(result, i), opt->topt.encoding);
  
        /* set cells */
        ncells = PQntuples(result) * nfields;
!       cells = calloc(ncells + 1, sizeof(*cells));
!       if (!cells)
!       {
!               fprintf(stderr, _("out of memory\n"));
!               exit(EXIT_FAILURE);
!       }
  
        for (i = 0; i < ncells; i++)
        {
--- 1747,1760 ----
        /* extract headers */
        nfields = PQnfields(result);
  
!       headers = pg_local_calloc(nfields + 1, sizeof(*headers));
  
        for (i = 0; i < nfields; i++)
                headers[i] = mbvalidate(PQfname(result, i), opt->topt.encoding);
  
        /* set cells */
        ncells = PQntuples(result) * nfields;
!       cells = pg_local_calloc(ncells + 1, sizeof(*cells));
  
        for (i = 0; i < ncells; i++)
        {
***************
*** 1646,1657 ****
                footers = opt->footers;
        else if (!opt->topt.expanded && opt->default_footer)
        {
!               footers = calloc(2, sizeof(*footers));
!               if (!footers)
!               {
!                       fprintf(stderr, _("out of memory\n"));
!                       exit(EXIT_FAILURE);
!               }
  
                footers[0] = pg_local_malloc(100);
                if (PQntuples(result) == 1)
--- 1770,1776 ----
                footers = opt->footers;
        else if (!opt->topt.expanded && opt->default_footer)
        {
!               footers = pg_local_calloc(2, sizeof(*footers));
  
                footers[0] = pg_local_malloc(100);
                if (PQntuples(result) == 1)
***************
*** 1663,1674 ****
                footers = NULL;
  
        /* set alignment */
!       align = calloc(nfields + 1, sizeof(*align));
!       if (!align)
!       {
!               fprintf(stderr, _("out of memory\n"));
!               exit(EXIT_FAILURE);
!       }
  
        for (i = 0; i < nfields; i++)
        {
--- 1782,1788 ----
                footers = NULL;
  
        /* set alignment */
!       align = pg_local_calloc(nfields + 1, sizeof(*align));
  
        for (i = 0; i < nfields; i++)
        {
---------------------------(end of broadcast)---------------------------
TIP 9: In versions below 8.0, the planner will ignore your desire to
       choose an index scan if your joining column's datatypes do not
       match

Reply via email to