NetBSD/MIPS supports dlopen

? psql
? psql_wrapping.patch
Index: command.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.186
diff -c -r1.186 command.c
*** command.c	1 Jan 2008 19:45:55 -0000	1.186
--- command.c	5 Mar 2008 20:57:05 -0000
***************
*** 1526,1531 ****
--- 1526,1534 ----
  		case PRINT_ALIGNED:
  			return "aligned";
  			break;
+ 		case PRINT_ALIGNEDWRAP:
+ 			return "aligned-wrapped";
+ 			break;
  		case PRINT_HTML:
  			return "html";
  			break;
***************
*** 1559,1564 ****
--- 1562,1569 ----
  			popt->topt.format = PRINT_UNALIGNED;
  		else if (pg_strncasecmp("aligned", value, vallen) == 0)
  			popt->topt.format = PRINT_ALIGNED;
+ 		else if (pg_strncasecmp("aligned-wrapped", value, vallen) == 0)
+ 			popt->topt.format = PRINT_ALIGNEDWRAP;
  		else if (pg_strncasecmp("html", value, vallen) == 0)
  			popt->topt.format = PRINT_HTML;
  		else if (pg_strncasecmp("latex", value, vallen) == 0)
***************
*** 1567,1573 ****
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, html, latex, troff-ms\n");
  			return false;
  		}
  
--- 1572,1578 ----
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, aligned-wrapped, html, latex, troff-ms\n");
  			return false;
  		}
  
Index: mbprint.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.29
diff -c -r1.29 mbprint.c
*** mbprint.c	1 Jan 2008 19:45:56 -0000	1.29
--- mbprint.c	5 Mar 2008 20:57:06 -0000
***************
*** 205,211 ****
   * 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
--- 205,211 ----
   * 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_height: Number of lines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
  int
***************
*** 279,284 ****
--- 279,288 ----
  	return width;
  }
  
+ /*
+ **  Filter out unprintable characters, companion to wcs_size.
+ **  Break input into lines (based on \n or \r).
+ */
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
  			 struct lineptr * lines, int count)
***************
*** 353,364 ****
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';
  	lines->width = linewidth;
! 	lines++;
! 	count--;
! 	if (count > 0)
! 		lines->ptr = NULL;
  }
  
  unsigned char *
--- 357,370 ----
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';          // Terminate formatted string
  	lines->width = linewidth;
!     // Fill remaining array slots with null
! 	while(--count) {
!         lines++;                
! 		lines->ptr   = NULL;
! 		lines->width = 0;
!         }
  }
  
  unsigned char *
Index: print.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.96
diff -c -r1.96 print.c
*** print.c	1 Jan 2008 19:45:56 -0000	1.96
--- print.c	5 Mar 2008 20:57:07 -0000
***************
*** 398,403 ****
--- 398,406 ----
  }
  
  
+ //
+ //  Prety pretty boxes around cells.
+ //
  static void
  print_aligned_text(const char *title, const char *const * headers,
  				   const char *const * cells, const char *const * footers,
***************
*** 406,431 ****
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
- 	unsigned short int opt_border = opt->border;
  	int			encoding = opt->encoding;
  	unsigned int col_count = 0;
! 	unsigned int cell_count = 0;
! 	unsigned int i;
  	int			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 */
  
  	if (cancel_pressed)
  		return;
--- 409,436 ----
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
  	int			encoding = opt->encoding;
+ 	unsigned short int opt_border = opt->border;
+ 
  	unsigned int col_count = 0;
! 
! 	unsigned int i,j;
  	int			tmp;
! 
! 	unsigned int *width_header, *width_max, *width_wrap, *width_average;
!     unsigned int *heights, *format_space;
  	unsigned char **format_buf;
+     unsigned int total_w;
  
  	const char *const * ptr;
  
! 	struct lineptr **col_lineptrs;	/* pointers to line pointer per column */
! 	struct lineptr *lineptr_list;	/* complete list of linepointers */
  
  	int		   *complete;		/* Array remembering which columns have
  								 * completed output */
+     int         tcolumns = 0;   // Width of interactive console
+     int         rows=0;         // SQL rows in result (calculated)
  
  	if (cancel_pressed)
  		return;
***************
*** 439,446 ****
  
  	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));
--- 444,454 ----
  
  	if (col_count > 0)
  	{
! 		width_header  = pg_local_calloc(col_count, sizeof(*width_header));
! 		width_average = pg_local_calloc(col_count, sizeof(*width_average));
! 		width_max     = pg_local_calloc(col_count, sizeof(*width_max));
! 		width_wrap    = pg_local_calloc(col_count, sizeof(*width_wrap));
! 		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));
***************
*** 448,466 ****
  	}
  	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 */
--- 456,473 ----
  	}
  	else
  	{
! 		width_header  = NULL;
! 		width_average = NULL;
! 		width_max     = NULL;
! 		width_wrap    = NULL;
! 		heights    = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
  		format_buf = NULL;
  		complete = NULL;
  	}
  
! 	/* scan all column headers, find maximum width */
  	for (i = 0; i < col_count; i++)
  	{
  		/* Get width & height */
***************
*** 468,503 ****
  					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)
  		total_w = col_count - 1;
  	else if (opt_border == 1)
--- 475,518 ----
  					space;
  
  		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &tmp, &height, &space);
! 		if (tmp > width_max[i])
! 			width_max[i] = tmp;
  		if (height > heights[i])
  			heights[i] = height;
  		if (space > format_space[i])
  			format_space[i] = space;
+ 
+         width_header[i] = tmp;
  	}
  
+ 	/* scan all rows, find maximum width */
  	for (i = 0, ptr = cells; *ptr; ptr++, i++)
  	{
! 		int	height, space;
  
  		/* Get width, ignore height */
  		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &tmp, &height, &space);
! 		if (opt_numeric_locale && opt_align[i % col_count] == 'r') {
! 			tmp += additional_numeric_locale_len(*ptr);
! 			space += additional_numeric_locale_len(*ptr);
!             }
! 
! 		if (tmp > width_max[i % col_count])
! 			width_max[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;
+ 
+         width_average[i % col_count] += tmp;
  	}
+     rows=(i / col_count);
+ 	for (i = 0; i < col_count; i++) {
+         if( rows )
+             width_average[i % col_count] /= rows;
+         }
  
+ 	/* fiddle total display width based on border style */
  	if (opt_border == 0)
  		total_w = col_count - 1;
  	else if (opt_border == 1)
***************
*** 505,518 ****
  	else
  		total_w = col_count * 3 + 1;
  
! 	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
  	 */
  	if (col_count > 0)
  	{
--- 520,536 ----
  	else
  		total_w = col_count * 3 + 1;
  
! 	for (i = 0; i < col_count; i++) {
! 		total_w += width_max[i];
!         }
  
  	/*
! 	 * At this point:
!      *  width_max[] contains the max width of each column
!      *  heights[] contains the max number of lines in each column
!      *  format_space[] contains the maximum storage space for formatting strings
!      *  total_w contains the giant width sum
!      * Now we allocate some memory...
  	 */
  	if (col_count > 0)
  	{
***************
*** 529,535 ****
  			col_lineptrs[i] = lineptr;
  			lineptr += heights[i];
  
! 			format_buf[i] = pg_local_malloc(format_space[i]);
  
  			col_lineptrs[i]->ptr = format_buf[i];
  		}
--- 547,553 ----
  			col_lineptrs[i] = lineptr;
  			lineptr += heights[i];
  
! 			format_buf[i] = pg_local_malloc(format_space[i]+1);
  
  			col_lineptrs[i]->ptr = format_buf[i];
  		}
***************
*** 537,555 ****
  	else
  		lineptr_list = NULL;
  
  	if (opt->start_table)
  	{
  		/* 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
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);
  		}
  
  		/* print headers */
--- 555,635 ----
  	else
  		lineptr_list = NULL;
  
+ 
+     /*
+     **  Default the word wrap to the full width (e.g. no word wrap)
+     */
+     for (i = 0; i < col_count; i++)
+     {
+         width_wrap[i] = width_max[i]; 
+     }
+ 
+     /*
+     **  Optional optimized word wrap.
+     **  Shrink columns with a high max/avg ratio.
+     **  Slighly bias against wider columns (increasnig chance
+     **  a narrow column will fit in its cell)
+     **
+     **  Created March 2008, Bryce Nesbitt
+     */
+     if( opt->format == PRINT_ALIGNEDWRAP )
+     {
+         // If we can get the terminal width
+         char * temp = getenv("COLUMNS");
+         if( temp != NULL )
+             {
+             tcolumns = atoi(temp);
+ 
+             // Shink high ratio columns
+             while( total_w > tcolumns)  
+             {
+                 double ratio    = 0;
+                 double temp     = 0;
+                 int    worstcol = -1;
+                 for (i = 0; i < col_count; i++)
+                     if( width_average[i] )
+                         if( width_wrap[i] > width_header[i] )
+                         {
+                             temp  =(double)width_wrap[i]/width_average[i];
+                             temp +=width_max[i] * .01; // Penalize wide columns
+                             if( temp > ratio )
+                                 ratio = temp, worstcol=i;
+                         }
+ 
+                 // Debugging -- please leave in source!
+                 if( true )
+                 {
+                 fprintf(fout, "Wrap ratio=");
+                 for (i = 0; i < col_count; i++)
+                     fprintf(fout, "%f %f  ",(double)width_wrap[i]/width_average[i] + width_max[i] * .01, width_max[i] * .01);
+                 fprintf(fout, "\n");
+                 }
+ 
+                 // Exit loop if we can't squeeze any more.
+                 if( worstcol < 0 ) 
+                     break;
+ 
+                 // Squeeze the worst column.  Lather, rinse, repeat
+                 width_wrap[worstcol]--;
+                 total_w--;
+             }
+         }
+     }
+ 
+     /* 
+     ** Woo, hoo, time to output
+     */
  	if (opt->start_table)
  	{
  		/* print title */
  		if (title && !opt_tuples_only)
  		{
  			int			height;
  			pg_wcssize((unsigned char *) title, strlen(title), encoding, &tmp, &height, NULL);
  			if (tmp >= total_w)
! 				fprintf(fout, "%s\n", title);                               // Aligned
  			else
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);  // Centered
  		}
  
  		/* print headers */
***************
*** 559,565 ****
  			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]);
--- 639,645 ----
  			int			line_count;
  
  			if (opt_border == 2)
! 				_print_horizontal_line(col_count, width_wrap, 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]);
***************
*** 582,588 ****
  
  					if (!complete[i])
  					{
! 						nbspace = widths[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
--- 662,668 ----
  
  					if (!complete[i])
  					{
! 						nbspace = width_wrap[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
***************
*** 595,601 ****
  						}
  					}
  					else
! 						fprintf(fout, "%*s", widths[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
--- 675,681 ----
  						}
  					}
  					else
! 						fprintf(fout, "%*s", width_wrap[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
***************
*** 613,713 ****
  				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 */
  
  		if (cancel_pressed)
  			break;
  
  		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;
! 				bool		finalspaces = (opt_border == 2 || j != col_count - 1);
! 
! 				if (complete[j])	/* Just print spaces... */
! 				{
! 					if (finalspaces)
! 						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((char *) this_line->ptr);
! 
! 							fprintf(fout, "%*s%s",
! 									(int) (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,
! 						finalspaces ? (widths[j] - this_line->width) : 0, "");
! 					/* 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++;
! 		}
! 	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, widths, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
--- 693,821 ----
  				fputc('\n', fout);
  			}
  
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  		}
  	}
  
  	/* print cells */
  	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
  	{
! 		bool		line_todo,cols_todo;
! 		int			line_count;
  
  		if (cancel_pressed)
  			break;
  
+         // Format each cell.  Format again, it is a numeric formatting locale (e.g. 123,456 vs. 123456)
  		for (j = 0; j < col_count; j++)
+         {
  			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], heights[j]);
+             if (opt_numeric_locale && opt_align[j % col_count] == 'r')
+                 {
+                 char *my_cell;
+                 my_cell = format_numeric_locale((char *)col_lineptrs[j]->ptr);
+                 strcpy((char *)col_lineptrs[j]->ptr, my_cell);  // Buffer IS large enough... now
+                 free(my_cell);
+                 }
+         }
  
!         // Print rows to console
  		memset(complete, 0, col_count * sizeof(int));
! 		line_count = 0;
!         line_todo  = true;
!         while (line_todo)
!         {
!             cols_todo  = true;
!             while (cols_todo)
!             {
!                 char    border_cell = '*';
!                 cols_todo = false;
! 
!                 /* left border */
!                 if (opt_border == 2)
!                     fputs("| ", fout);
!                 else if (opt_border == 1)
!                     fputc(' ', fout);
! 
!                 /* for each column */
!                 for (j = 0; j < col_count; j++)
!                 {
!                     struct lineptr *this_line = &col_lineptrs[j][line_count];
! 
!                     if( heights[j] <= line_count ) { // Blank column content
!                         fprintf(fout, "%*s", width_wrap[j], "");
!                         border_cell = '|';
!                         }
!                     else if (opt_align[j] == 'r')    // Right aligned cell
!                     {
!                         int    strlen_remaining   = strlen((char *)this_line->ptr+complete[j]);
!                         if( strlen_remaining > width_wrap[j] )
!                         {
!                             fprintf(fout, "%.*s", width_wrap[j], this_line->ptr+complete[j] );
!                             complete[j] += width_wrap[j];   // We've done THIS much
!                             cols_todo = true;               // And there is more to do...
!                             border_cell = ':';
!                         } else
!                         {
!                             fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
!                             fprintf(fout, "%-s", this_line->ptr + complete[j] );
!                             complete[j] += strlen_remaining;
!                             border_cell = '|';
!                         }
!                     }
!                     else    // Left aligned cell
!                     {
!                         int    strlen_remaining   = strlen((char *)this_line->ptr+complete[j]);
!                         if( strlen_remaining > width_wrap[j] )
!                         {
!                             fprintf(fout, "%.*s", width_wrap[j], this_line->ptr+complete[j] );
!                             complete[j] += width_wrap[j];   // We've done THIS much
!                             cols_todo = true;               // And there is more to do...
!                             border_cell = ':';
!                         } else
!                         {
!                             fprintf(fout, "%-s", this_line->ptr + complete[j] );
!                             fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
!                             complete[j] += strlen_remaining;
!                             border_cell = '|';
!                         }
!                     }
! 
!                     /* print a divider, middle of columns only */
!                     if ((j + 1) % col_count)
!                     {
!                         if (opt_border == 0)
!                             fputc(' ', fout);
!                         else
!                             fprintf(fout, " %c ", border_cell);
!                     }
!                 }
! 
!                 /* end of row border */
!                 if (opt_border == 2)
!                     fprintf(fout, " %c", border_cell);
!                 fputc('\n', fout);
!             }
! 
!             // Check if any columns have line continuations (due to \n in the cell)
!             line_count++;
!             line_todo = false;
!             for (j = 0; j < col_count; j++)
!             {
!                 if( line_count < heights[j]) {
!                     if( col_lineptrs[j][line_count].ptr ) {
!                         line_todo = true;
!                         complete[j]=0;
!                         }
!                     }
!             }
!         }
!     }
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
***************
*** 724,730 ****
  	}
  
  	/* clean up */
! 	free(widths);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
--- 832,841 ----
  	}
  
  	/* clean up */
! 	free(width_header);
! 	free(width_average);
! 	free(width_max);
! 	free(width_wrap);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
***************
*** 1881,1886 ****
--- 1992,1998 ----
  									 opt, output);
  			break;
  		case PRINT_ALIGNED:
+ 		case PRINT_ALIGNEDWRAP:
  			if (opt->expanded)
  				print_aligned_vertical(title, headers, cells, footers, align,
  									   opt, output);
Index: print.h
===================================================================
RCS file: /projects/cvsroot/pgsql/src/bin/psql/print.h,v
retrieving revision 1.35
diff -c -r1.35 print.h
*** print.h	1 Jan 2008 19:45:56 -0000	1.35
--- print.h	5 Mar 2008 20:57:07 -0000
***************
*** 21,26 ****
--- 21,27 ----
  	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
  	PRINT_UNALIGNED,
  	PRINT_ALIGNED,
+ 	PRINT_ALIGNEDWRAP,
  	PRINT_HTML,
  	PRINT_LATEX,
  	PRINT_TROFF_MS

Index: doc/src/sgml/ref/psql-ref.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v
retrieving revision 1.199
diff -c -c -r1.199 psql-ref.sgml
*** doc/src/sgml/ref/psql-ref.sgml	30 Mar 2008 18:10:20 -0000	1.199
--- doc/src/sgml/ref/psql-ref.sgml	17 Apr 2008 02:45:38 -0000
***************
*** 1513,1519 ****
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
--- 1513,1520 ----
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>wrapped</literal>, 
!           <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
***************
*** 1525,1531 ****
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default. The
            <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
--- 1526,1535 ----
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default.
!           <quote>Wrapped</quote> is like <literal>aligned</> but wraps
!           the output to fit the screen's width, based on the environment
!           variable <envar>COLUMNS</> or the autodetected width. The
            <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
***************
*** 2708,2713 ****
--- 2712,2730 ----
  
    <variablelist>
     <varlistentry>
+     <term><envar>COLUMNS</envar></term>
+ 
+     <listitem>
+      <para>
+       The character width to wrap output in <literal>wrapped</> format
+       mode.  Many shells automatically update <envar>COLUMNS</> when
+       a window is resized.  If not set the screen width is automatically
+       detected, if possible.
+      </para>
+     </listitem>
+    </varlistentry>
+ 
+    <varlistentry>
      <term><envar>PAGER</envar></term>
  
      <listitem>
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.186
diff -c -c -r1.186 command.c
*** src/bin/psql/command.c	1 Jan 2008 19:45:55 -0000	1.186
--- src/bin/psql/command.c	17 Apr 2008 02:45:38 -0000
***************
*** 1526,1531 ****
--- 1526,1534 ----
  		case PRINT_ALIGNED:
  			return "aligned";
  			break;
+ 		case PRINT_WRAP:
+ 			return "wrapped";
+ 			break;
  		case PRINT_HTML:
  			return "html";
  			break;
***************
*** 1559,1564 ****
--- 1562,1569 ----
  			popt->topt.format = PRINT_UNALIGNED;
  		else if (pg_strncasecmp("aligned", value, vallen) == 0)
  			popt->topt.format = PRINT_ALIGNED;
+ 		else if (pg_strncasecmp("wrapped", value, vallen) == 0)
+ 			popt->topt.format = PRINT_WRAP;
  		else if (pg_strncasecmp("html", value, vallen) == 0)
  			popt->topt.format = PRINT_HTML;
  		else if (pg_strncasecmp("latex", value, vallen) == 0)
***************
*** 1567,1573 ****
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, html, latex, troff-ms\n");
  			return false;
  		}
  
--- 1572,1578 ----
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n");
  			return false;
  		}
  
Index: src/bin/psql/mbprint.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.30
diff -c -c -r1.30 mbprint.c
*** src/bin/psql/mbprint.c	16 Apr 2008 18:18:00 -0000	1.30
--- src/bin/psql/mbprint.c	17 Apr 2008 02:45:38 -0000
***************
*** 279,284 ****
--- 279,288 ----
  	return width;
  }
  
+ /*
+  *  Filter out unprintable characters, companion to wcs_size.
+  *  Break input into lines (based on \n or \r).
+  */
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
  			 struct lineptr * lines, int count)
***************
*** 353,364 ****
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';
  	lines->width = linewidth;
! 	lines++;
! 	count--;
! 	if (count > 0)
  		lines->ptr = NULL;
  }
  
  unsigned char *
--- 357,373 ----
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';			/* Terminate formatted string */
! 
  	lines->width = linewidth;
! 
! 	/* Fill remaining array slots with nulls */
! 	while (--count)
! 	{
! 		lines++;			    
  		lines->ptr = NULL;
+ 		lines->width = 0;
+ 	}
  }
  
  unsigned char *
Index: src/bin/psql/print.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.97
diff -c -c -r1.97 print.c
*** src/bin/psql/print.c	27 Mar 2008 03:57:34 -0000	1.97
--- src/bin/psql/print.c	17 Apr 2008 02:45:38 -0000
***************
*** 396,401 ****
--- 396,404 ----
  }
  
  
+ /*
+  *	Prety pretty boxes around cells.
+  */
  static void
  print_aligned_text(const char *title, const char *const * headers,
  				   const char *const * cells, const char *const * footers,
***************
*** 404,429 ****
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
- 	unsigned short int opt_border = opt->border;
  	int			encoding = opt->encoding;
! 	unsigned int col_count = 0;
! 	unsigned int cell_count = 0;
! 	unsigned int i;
! 	int			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 */
  
  	if (cancel_pressed)
  		return;
--- 407,437 ----
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
  	int			encoding = opt->encoding;
! 	unsigned short int opt_border = opt->border;
! 
! 	unsigned int col_count = 0, cell_count = 0;
! 
! 	unsigned int i,
! 				j;
! 
! 	unsigned int *width_header,
! 			   *width_max,
! 			   *width_wrap,
! 			   *width_average;
! 	unsigned int *heights,
! 			   *format_space;
  	unsigned char **format_buf;
+ 	unsigned int width_total;
  
  	const char *const * ptr;
  
! 	struct lineptr **col_lineptrs;		/* pointers to line pointer per column */
  	struct lineptr *lineptr_list;		/* complete list of linepointers */
  
  	int		   *complete;		/* Array remembering which columns have
  								 * completed output */
+ 	int			tcolumns = 0;	/* Width of interactive console */
  
  	if (cancel_pressed)
  		return;
***************
*** 437,443 ****
  
  	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));
--- 445,454 ----
  
  	if (col_count > 0)
  	{
! 		width_header = pg_local_calloc(col_count, sizeof(*width_header));
! 		width_average = pg_local_calloc(col_count, sizeof(*width_average));
! 		width_max = pg_local_calloc(col_count, sizeof(*width_max));
! 		width_wrap = pg_local_calloc(col_count, sizeof(*width_wrap));
  		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));
***************
*** 446,452 ****
  	}
  	else
  	{
! 		widths = NULL;
  		heights = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
--- 457,466 ----
  	}
  	else
  	{
! 		width_header = NULL;
! 		width_average = NULL;
! 		width_max = NULL;
! 		width_wrap = NULL;
  		heights = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
***************
*** 454,533 ****
  		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)
! 		total_w = col_count - 1;
  	else if (opt_border == 1)
! 		total_w = col_count * 3 - 1;
  	else
! 		total_w = col_count * 3 + 1;
  
  	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
  	 */
  	if (col_count > 0)
  	{
! 		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];
  		}
--- 468,560 ----
  		complete = NULL;
  	}
  
! 	/* scan all column headers, find maximum width */
  	for (i = 0; i < col_count; i++)
  	{
  		/* Get width & height */
! 		int			width,
! 					height,
  					space;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &space);
! 		if (width > width_max[i])
! 			width_max[i] = width;
  		if (height > heights[i])
  			heights[i] = height;
  		if (space > format_space[i])
  			format_space[i] = space;
+ 
+ 		width_header[i] = width;
  	}
  
! 	/* scan all rows, find maximum width, compute cell_count */
! 	for (i = 0, ptr = cells; *ptr; ptr++, i++, cell_count++)
  	{
! 		int			width,
! 					height,
  					space;
  
  		/* Get width, ignore height */
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &space);
! 		if (opt_numeric_locale && opt_align[i % col_count] == 'r')
! 		{
! 			width += additional_numeric_locale_len(*ptr);
! 			space += additional_numeric_locale_len(*ptr);
! 		}
! 
! 		if (width > width_max[i % col_count])
! 			width_max[i % col_count] = width;
  		if (height > heights[i % col_count])
  			heights[i % col_count] = height;
  		if (space > format_space[i % col_count])
  			format_space[i % col_count] = space;
+ 
+ 		width_average[i % col_count] += width;
+ 	}
+ 
+ 	/* If we have rows, compute average */
+ 	if (col_count != 0 && cell_count != 0)
+ 	{
+ 		int rows = cell_count / col_count;
+ 		
+ 		for (i = 0; i < col_count; i++)
+ 			width_average[i % col_count] /= rows;
  	}
  
+ 	/* adjust the total display width based on border style */
  	if (opt_border == 0)
! 		width_total = col_count - 1;
  	else if (opt_border == 1)
! 		width_total = col_count * 3 - 1;
  	else
! 		width_total = col_count * 3 + 1;
  
  	for (i = 0; i < col_count; i++)
! 		width_total += width_max[i];
  
  	/*
! 	 * At this point: width_max[] contains the max width of each column,
! 	 * heights[] contains the max number of lines in each column,
! 	 * format_space[] contains the maximum storage space for formatting
! 	 * strings, width_total contains the giant width sum.  Now we allocate
! 	 * some memory...
  	 */
  	if (col_count > 0)
  	{
! 		int			height_total = 0;
  		struct lineptr *lineptr;
  
  		for (i = 0; i < col_count; i++)
! 			height_total += heights[i];
  
! 		lineptr = lineptr_list = pg_local_calloc(height_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] + 1);
  
  			col_lineptrs[i]->ptr = format_buf[i];
  		}
***************
*** 535,553 ****
  	else
  		lineptr_list = NULL;
  
  	if (opt->start_table)
  	{
  		/* 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
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);
  		}
  
  		/* print headers */
--- 562,650 ----
  	else
  		lineptr_list = NULL;
  
+ 
+ 	/* Default word wrap to the full width, i.e. no word wrap */
+ 	for (i = 0; i < col_count; i++)
+ 		width_wrap[i] = width_max[i];
+ 
+ 	/*
+ 	 * Optional optimized word wrap. Shrink columns with a high max/avg ratio.
+ 	 * Slighly bias against wider columns (increases chance a narrow column
+ 	 * will fit in its cell)
+ 	 */
+ 	if (opt->format == PRINT_WRAP)
+ 	{
+ 		/* If we can get the terminal width */
+ 		char	   *env = getenv("COLUMNS");
+ 
+ 		if (env != NULL)
+ 			tcolumns = atoi(env);
+ #ifdef TIOCGWINSZ
+ 		else
+ 		{
+ 			struct winsize screen_size;
+ 
+ 			if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
+ 				tcolumns = screen_size.ws_col;
+ 		}
+ #endif
+ 			
+ 		if (tcolumns > 0)
+ 		{
+ 			/* Shink high ratio columns */
+ 			while (width_total > tcolumns)
+ 			{
+ 				double		ratio = 0;
+ 				double		curr_ratio = 0;
+ 				int			worst_col = -1;
+ 
+ 				/*
+ 				 *	Find column that has the highest ratio of its maximum
+ 				 *	width compared to its average width.  This tells us which
+ 				 *	column will produce the fewest wrapped values if shortened.
+ 				 *	width_wrap starts as equal to width_max.
+ 				 */
+ 				for (i = 0; i < col_count; i++)
+ 					if (width_average[i] && width_wrap[i] > width_header[i])
+ 					{
+ 						curr_ratio = (double) width_wrap[i] / width_average[i];
+ 						curr_ratio += width_max[i] * 0.01;		/* Penalize wide columns */
+ 						if (curr_ratio > ratio)
+ 						{
+ 							ratio = curr_ratio;
+ 							worst_col = i;
+ 						}
+ 					}
+ 
+ 				/* Exit loop if we can't squeeze any more. */
+ 				if (worst_col < 0)
+ 					break;
+ 
+ 				/* Squeeze the worst column.  Lather, rinse, repeat */
+ 				/*
+ 				 *	XXX This only reduces one character at a time so might
+ 				 *	be inefficient for very long rows.
+ 				 */
+ 				width_wrap[worst_col]--;
+ 				width_total--;
+ 			}
+ 		}
+ 	}
+ 
+ 	/* time to output */
  	if (opt->start_table)
  	{
  		/* print title */
  		if (title && !opt_tuples_only)
  		{
! 			int			width,
! 						height;
  
! 			pg_wcssize((unsigned char *) title, strlen(title), encoding, &width, &height, NULL);
! 			if (width >= width_total)
! 				fprintf(fout, "%s\n", title);	/* Aligned */
  			else
! 				fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "", title);		/* Centered */
  		}
  
  		/* print headers */
***************
*** 557,563 ****
  			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]);
--- 654,660 ----
  			int			line_count;
  
  			if (opt_border == 2)
! 				_print_horizontal_line(col_count, width_wrap, 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]);
***************
*** 580,586 ****
  
  					if (!complete[i])
  					{
! 						nbspace = widths[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
--- 677,683 ----
  
  					if (!complete[i])
  					{
! 						nbspace = width_wrap[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
***************
*** 593,599 ****
  						}
  					}
  					else
! 						fprintf(fout, "%*s", widths[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
--- 690,696 ----
  						}
  					}
  					else
! 						fprintf(fout, "%*s", width_wrap[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
***************
*** 611,711 ****
  				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 */
  
  		if (cancel_pressed)
  			break;
  
  		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;
! 				bool		finalspaces = (opt_border == 2 || j != col_count - 1);
  
! 				if (complete[j])	/* Just print spaces... */
! 				{
! 					if (finalspaces)
! 						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((char *) this_line->ptr);
! 
! 							fprintf(fout, "%*s%s",
! 									(int) (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,
! 						finalspaces ? (widths[j] - this_line->width) : 0, "");
! 					/* 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++;
  		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, widths, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
--- 708,855 ----
  				fputc('\n', fout);
  			}
  
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  		}
  	}
  
  	/* print cells */
  	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
  	{
! 		bool		line_todo,
! 					cols_todo;
! 		int			line_count;
  
  		if (cancel_pressed)
  			break;
  
+ 		/*
+ 		 * Format each cell.  Format again, it is a numeric formatting locale
+ 		 * (e.g. 123,456 vs. 123456)
+ 		 */
  		for (j = 0; j < col_count; j++)
+ 		{
  			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], heights[j]);
+ 			if (opt_numeric_locale && opt_align[j % col_count] == 'r')
+ 			{
+ 				char	   *my_cell;
  
! 				my_cell = format_numeric_locale((char *) col_lineptrs[j]->ptr);
! 				strcpy((char *) col_lineptrs[j]->ptr, my_cell); /* Buffer IS large
! 																 * enough... now */
! 				free(my_cell);
! 			}
! 		}
! 
! 		/* Print rows to console */
  		memset(complete, 0, col_count * sizeof(int));
! 		line_count = 0;
! 		line_todo = true;
! 		while (line_todo)
  		{
! 			cols_todo = true;
! 			while (cols_todo)
  			{
! 				char	border_cell = '*';
  
! 				cols_todo = false;
! 
! 				/* left border */
! 				if (opt_border == 2)
! 					fputs("| ", fout);
! 				else if (opt_border == 1)
! 					fputc(' ', fout);
! 
! 				/* for each column */
! 				for (j = 0; j < col_count; j++)
  				{
! 					struct lineptr *this_line = &col_lineptrs[j][line_count];
! 
! 					if (heights[j] <= line_count)		/* Blank column content */
! 					{
! 						fprintf(fout, "%*s", width_wrap[j], "");
! 						border_cell = '|';
! 					}
! 					else if (opt_align[j] == 'r')		/* Right aligned cell */
  					{
! 						int		strlen_remaining = strlen((char *) this_line->ptr + complete[j]);
! 
! 						if (strlen_remaining > width_wrap[j])
  						{
! 							fprintf(fout, "%.*s", (int) width_wrap[j], this_line->ptr + complete[j]);
! 							complete[j] += width_wrap[j];		/* We've done THIS much */
! 							cols_todo = true;	/* And there is more to do... */
! 							border_cell = ':';
  						}
  						else
! 						{
! 							fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
! 							fprintf(fout, "%-s", this_line->ptr + complete[j]);
! 							complete[j] += strlen_remaining;
! 							border_cell = '|';
! 						}
  					}
! 					else	/* Left aligned cell */
  					{
! 						int		strlen_remaining = strlen((char *) this_line->ptr + complete[j]);
! 
! 						if (strlen_remaining > width_wrap[j])
! 						{
! 							fprintf(fout, "%.*s", (int) width_wrap[j], this_line->ptr + complete[j]);
! 							complete[j] += width_wrap[j];		/* We've done THIS much */
! 							cols_todo = true;	/* And there is more to do... */
! 							border_cell = ':';
! 						}
! 						else
! 						{
! 							fprintf(fout, "%-s", this_line->ptr + complete[j]);
! 							fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
! 							complete[j] += strlen_remaining;
! 							border_cell = '|';
! 						}
! 					}
! 
! 					/* print a divider, middle of columns only */
! 					if ((j + 1) % col_count)
! 					{
! 						if (opt_border == 0)
! 							fputc(' ', fout);
! 						else if (line_count == 0)
! 							fprintf(fout, " %c ", border_cell);
! 						else
! 							fprintf(fout, " %c ", complete[j + 1] ? ' ' : ':');
  					}
  				}
  
! 				/* end of row border */
! 				if (opt_border == 2)
! 					fprintf(fout, " %c", border_cell);
! 				fputc('\n', fout);
! 			}
! 
! 			/*
! 			 * Check if any columns have line continuations due to \n in the
! 			 * cell.
! 			 */
! 			line_count++;
! 			line_todo = false;
! 			for (j = 0; j < col_count; j++)
! 			{
! 				if (line_count < heights[j])
  				{
! 					if (col_lineptrs[j][line_count].ptr)
! 					{
! 						line_todo = true;
! 						complete[j] = 0;
! 					}
  				}
  			}
  		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
***************
*** 722,728 ****
  	}
  
  	/* clean up */
! 	free(widths);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
--- 866,875 ----
  	}
  
  	/* clean up */
! 	free(width_header);
! 	free(width_average);
! 	free(width_max);
! 	free(width_wrap);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
***************
*** 754,760 ****
  				dheight = 1,
  				hformatsize = 0,
  				dformatsize = 0;
- 	int			tmp = 0;
  	char	   *divider;
  	unsigned int cell_count = 0;
  	struct lineptr *hlineptr,
--- 901,906 ----
***************
*** 779,790 ****
  	/* 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)
--- 925,937 ----
  	/* Find the maximum dimensions for the headers */
  	for (i = 0; i < col_count; i++)
  	{
! 		int			width,
! 					height,
  					fs;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &fs);
! 		if (width > hwidth)
! 			hwidth = width;
  		if (height > hheight)
  			hheight = height;
  		if (fs > hformatsize)
***************
*** 799,805 ****
  	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)
--- 946,953 ----
  	for (i = 0, ptr = cells; *ptr; ptr++, i++)
  	{
  		int			numeric_locale_len;
! 		int			width,
! 					height,
  					fs;
  
  		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
***************
*** 807,816 ****
  		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)
--- 955,964 ----
  		else
  			numeric_locale_len = 0;
  
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &fs);
! 		width += numeric_locale_len;
! 		if (width > dwidth)
! 			dwidth = width;
  		if (height > dheight)
  			dheight = height;
  		if (fs > dformatsize)
***************
*** 1879,1884 ****
--- 2027,2033 ----
  									 opt, output);
  			break;
  		case PRINT_ALIGNED:
+ 		case PRINT_WRAP:
  			if (opt->expanded)
  				print_aligned_vertical(title, headers, cells, footers, align,
  									   opt, output);
Index: src/bin/psql/print.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.h,v
retrieving revision 1.35
diff -c -c -r1.35 print.h
*** src/bin/psql/print.h	1 Jan 2008 19:45:56 -0000	1.35
--- src/bin/psql/print.h	17 Apr 2008 02:45:38 -0000
***************
*** 21,26 ****
--- 21,27 ----
  	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
  	PRINT_UNALIGNED,
  	PRINT_ALIGNED,
+ 	PRINT_WRAP,
  	PRINT_HTML,
  	PRINT_LATEX,
  	PRINT_TROFF_MS

Index: doc/src/sgml/ref/psql-ref.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v
retrieving revision 1.199
diff -c -c -r1.199 psql-ref.sgml
*** doc/src/sgml/ref/psql-ref.sgml	30 Mar 2008 18:10:20 -0000	1.199
--- doc/src/sgml/ref/psql-ref.sgml	17 Apr 2008 14:05:39 -0000
***************
*** 1513,1519 ****
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
--- 1513,1520 ----
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>wrapped</literal>, 
!           <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
***************
*** 1525,1531 ****
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default. The
            <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
--- 1526,1535 ----
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default.
!           <quote>Wrapped</quote> is like <literal>aligned</> but wraps
!           the output to fit the screen's width, based on the environment
!           variable <envar>COLUMNS</> or the autodetected width. The
            <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
***************
*** 2708,2713 ****
--- 2712,2730 ----
  
    <variablelist>
     <varlistentry>
+     <term><envar>COLUMNS</envar></term>
+ 
+     <listitem>
+      <para>
+       The character width to wrap output in <literal>wrapped</> format
+       mode.  Many shells automatically update <envar>COLUMNS</> when
+       a window is resized.  If not set the screen width is automatically
+       detected, if possible.
+      </para>
+     </listitem>
+    </varlistentry>
+ 
+    <varlistentry>
      <term><envar>PAGER</envar></term>
  
      <listitem>
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.186
diff -c -c -r1.186 command.c
*** src/bin/psql/command.c	1 Jan 2008 19:45:55 -0000	1.186
--- src/bin/psql/command.c	17 Apr 2008 14:05:39 -0000
***************
*** 1526,1531 ****
--- 1526,1534 ----
  		case PRINT_ALIGNED:
  			return "aligned";
  			break;
+ 		case PRINT_WRAP:
+ 			return "wrapped";
+ 			break;
  		case PRINT_HTML:
  			return "html";
  			break;
***************
*** 1559,1564 ****
--- 1562,1569 ----
  			popt->topt.format = PRINT_UNALIGNED;
  		else if (pg_strncasecmp("aligned", value, vallen) == 0)
  			popt->topt.format = PRINT_ALIGNED;
+ 		else if (pg_strncasecmp("wrapped", value, vallen) == 0)
+ 			popt->topt.format = PRINT_WRAP;
  		else if (pg_strncasecmp("html", value, vallen) == 0)
  			popt->topt.format = PRINT_HTML;
  		else if (pg_strncasecmp("latex", value, vallen) == 0)
***************
*** 1567,1573 ****
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, html, latex, troff-ms\n");
  			return false;
  		}
  
--- 1572,1578 ----
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n");
  			return false;
  		}
  
Index: src/bin/psql/mbprint.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.30
diff -c -c -r1.30 mbprint.c
*** src/bin/psql/mbprint.c	16 Apr 2008 18:18:00 -0000	1.30
--- src/bin/psql/mbprint.c	17 Apr 2008 14:05:40 -0000
***************
*** 279,284 ****
--- 279,288 ----
  	return width;
  }
  
+ /*
+  *  Filter out unprintable characters, companion to wcs_size.
+  *  Break input into lines (based on \n or \r).
+  */
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
  			 struct lineptr * lines, int count)
***************
*** 353,364 ****
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';
  	lines->width = linewidth;
! 	lines++;
! 	count--;
! 	if (count > 0)
  		lines->ptr = NULL;
  }
  
  unsigned char *
--- 357,373 ----
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';			/* Terminate formatted string */
! 
  	lines->width = linewidth;
! 
! 	/* Fill remaining array slots with nulls */
! 	while (--count)
! 	{
! 		lines++;			    
  		lines->ptr = NULL;
+ 		lines->width = 0;
+ 	}
  }
  
  unsigned char *
Index: src/bin/psql/print.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.97
diff -c -c -r1.97 print.c
*** src/bin/psql/print.c	27 Mar 2008 03:57:34 -0000	1.97
--- src/bin/psql/print.c	17 Apr 2008 14:05:40 -0000
***************
*** 43,48 ****
--- 43,52 ----
  static char *grouping;
  static char *thousands_sep;
  
+ #define COL_RATIO(col_num) \
+ 			((double) width_wrap[col_num] / width_average[col_num] + \
+ 			width_max[col_num] * 0.01)		/* Penalize wide columns */
+ 
  static void *
  pg_local_malloc(size_t size)
  {
***************
*** 396,401 ****
--- 400,408 ----
  }
  
  
+ /*
+  *	Prety pretty boxes around cells.
+  */
  static void
  print_aligned_text(const char *title, const char *const * headers,
  				   const char *const * cells, const char *const * footers,
***************
*** 404,429 ****
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
- 	unsigned short int opt_border = opt->border;
  	int			encoding = opt->encoding;
! 	unsigned int col_count = 0;
! 	unsigned int cell_count = 0;
! 	unsigned int i;
! 	int			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 */
  
  	if (cancel_pressed)
  		return;
--- 411,441 ----
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
  	int			encoding = opt->encoding;
! 	unsigned short int opt_border = opt->border;
! 
! 	unsigned int col_count = 0, cell_count = 0;
! 
! 	unsigned int i,
! 				j;
! 
! 	unsigned int *width_header,
! 			   *width_max,
! 			   *width_wrap,
! 			   *width_average;
! 	unsigned int *heights,
! 			   *format_space;
  	unsigned char **format_buf;
+ 	unsigned int width_total;
  
  	const char *const * ptr;
  
! 	struct lineptr **col_lineptrs;		/* pointers to line pointer per column */
  	struct lineptr *lineptr_list;		/* complete list of linepointers */
  
  	int		   *complete;		/* Array remembering which columns have
  								 * completed output */
+ 	int			tcolumns = 0;	/* Width of interactive console */
  
  	if (cancel_pressed)
  		return;
***************
*** 437,443 ****
  
  	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));
--- 449,458 ----
  
  	if (col_count > 0)
  	{
! 		width_header = pg_local_calloc(col_count, sizeof(*width_header));
! 		width_average = pg_local_calloc(col_count, sizeof(*width_average));
! 		width_max = pg_local_calloc(col_count, sizeof(*width_max));
! 		width_wrap = pg_local_calloc(col_count, sizeof(*width_wrap));
  		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));
***************
*** 446,452 ****
  	}
  	else
  	{
! 		widths = NULL;
  		heights = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
--- 461,470 ----
  	}
  	else
  	{
! 		width_header = NULL;
! 		width_average = NULL;
! 		width_max = NULL;
! 		width_wrap = NULL;
  		heights = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
***************
*** 454,533 ****
  		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)
! 		total_w = col_count - 1;
  	else if (opt_border == 1)
! 		total_w = col_count * 3 - 1;
  	else
! 		total_w = col_count * 3 + 1;
  
  	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
  	 */
  	if (col_count > 0)
  	{
! 		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];
  		}
--- 472,564 ----
  		complete = NULL;
  	}
  
! 	/* scan all column headers, find maximum width */
  	for (i = 0; i < col_count; i++)
  	{
  		/* Get width & height */
! 		int			width,
! 					height,
  					space;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &space);
! 		if (width > width_max[i])
! 			width_max[i] = width;
  		if (height > heights[i])
  			heights[i] = height;
  		if (space > format_space[i])
  			format_space[i] = space;
+ 
+ 		width_header[i] = width;
  	}
  
! 	/* scan all rows, find maximum width, compute cell_count */
! 	for (i = 0, ptr = cells; *ptr; ptr++, i++, cell_count++)
  	{
! 		int			width,
! 					height,
  					space;
  
  		/* Get width, ignore height */
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &space);
! 		if (opt_numeric_locale && opt_align[i % col_count] == 'r')
! 		{
! 			width += additional_numeric_locale_len(*ptr);
! 			space += additional_numeric_locale_len(*ptr);
! 		}
! 
! 		if (width > width_max[i % col_count])
! 			width_max[i % col_count] = width;
  		if (height > heights[i % col_count])
  			heights[i % col_count] = height;
  		if (space > format_space[i % col_count])
  			format_space[i % col_count] = space;
+ 
+ 		width_average[i % col_count] += width;
  	}
  
+ 	/* If we have rows, compute average */
+ 	if (col_count != 0 && cell_count != 0)
+ 	{
+ 		int rows = cell_count / col_count;
+ 		
+ 		for (i = 0; i < col_count; i++)
+ 			width_average[i % col_count] /= rows;
+ 	}
+ 
+ 	/* adjust the total display width based on border style */
  	if (opt_border == 0)
! 		width_total = col_count - 1;
  	else if (opt_border == 1)
! 		width_total = col_count * 3 - 1;
  	else
! 		width_total = col_count * 3 + 1;
  
  	for (i = 0; i < col_count; i++)
! 		width_total += width_max[i];
  
  	/*
! 	 * At this point: width_max[] contains the max width of each column,
! 	 * heights[] contains the max number of lines in each column,
! 	 * format_space[] contains the maximum storage space for formatting
! 	 * strings, width_total contains the giant width sum.  Now we allocate
! 	 * some memory...
  	 */
  	if (col_count > 0)
  	{
! 		int			height_total = 0;
  		struct lineptr *lineptr;
  
  		for (i = 0; i < col_count; i++)
! 			height_total += heights[i];
  
! 		lineptr = lineptr_list = pg_local_calloc(height_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] + 1);
  
  			col_lineptrs[i]->ptr = format_buf[i];
  		}
***************
*** 535,553 ****
  	else
  		lineptr_list = NULL;
  
  	if (opt->start_table)
  	{
  		/* 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
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);
  		}
  
  		/* print headers */
--- 566,652 ----
  	else
  		lineptr_list = NULL;
  
+ 
+ 	/* Default word wrap to the full width, i.e. no word wrap */
+ 	for (i = 0; i < col_count; i++)
+ 		width_wrap[i] = width_max[i];
+ 
+ 	/*
+ 	 * Optional optimized word wrap. Shrink columns with a high max/avg ratio.
+ 	 * Slighly bias against wider columns (increases chance a narrow column
+ 	 * will fit in its cell)
+ 	 */
+ 	if (opt->format == PRINT_WRAP)
+ 	{
+ 		/* If we can get the terminal width */
+ 		char	   *env = getenv("COLUMNS");
+ 
+ 		if (env != NULL)
+ 			tcolumns = atoi(env);
+ #ifdef TIOCGWINSZ
+ 		else
+ 		{
+ 			struct winsize screen_size;
+ 
+ 			if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
+ 				tcolumns = screen_size.ws_col;
+ 		}
+ #endif
+ 			
+ 		if (tcolumns > 0)
+ 		{
+ 			/* Shink high ratio columns */
+ 			while (width_total > tcolumns)
+ 			{
+ 				double		max_ratio = 0, prev_max_ratio = 0;
+ 				double		curr_ratio = 0;
+ 				int			worst_col = -1;
+ 
+ 				/*
+ 				 *	Find column that has the highest ratio of its maximum
+ 				 *	width compared to its average width.  This tells us which
+ 				 *	column will produce the fewest wrapped values if shortened.
+ 				 *	width_wrap starts as equal to width_max.
+ 				 */
+ 				for (i = 0; i < col_count; i++)
+ 					if (width_average[i] && width_wrap[i] > width_header[i])
+ 					{
+ 						if (COL_RATIO(i) > max_ratio)
+ 						{
+ 							prev_max_ratio = max_ratio;
+ 							max_ratio = curr_ratio;
+ 							worst_col = i;
+ 						}
+ 					}
+ 
+ 				/* Exit loop if we can't squeeze any more. */
+ 				if (worst_col < 0)
+ 					break;
+ 
+ 				/* Squeeze the worst column.  Lather, rinse, repeat */
+ 				do
+ 				{
+ 					width_wrap[worst_col]--;
+ 					width_total--;
+ 				} while (width_total > tcolumns && COL_RATIO(i) >= prev_max_ratio);
+ 			}
+ 		}
+ 	}
+ 
+ 	/* time to output */
  	if (opt->start_table)
  	{
  		/* print title */
  		if (title && !opt_tuples_only)
  		{
! 			int			width,
! 						height;
  
! 			pg_wcssize((unsigned char *) title, strlen(title), encoding, &width, &height, NULL);
! 			if (width >= width_total)
! 				fprintf(fout, "%s\n", title);	/* Aligned */
  			else
! 				fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "", title);		/* Centered */
  		}
  
  		/* print headers */
***************
*** 557,563 ****
  			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]);
--- 656,662 ----
  			int			line_count;
  
  			if (opt_border == 2)
! 				_print_horizontal_line(col_count, width_wrap, 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]);
***************
*** 580,586 ****
  
  					if (!complete[i])
  					{
! 						nbspace = widths[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
--- 679,685 ----
  
  					if (!complete[i])
  					{
! 						nbspace = width_wrap[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
***************
*** 593,599 ****
  						}
  					}
  					else
! 						fprintf(fout, "%*s", widths[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
--- 692,698 ----
  						}
  					}
  					else
! 						fprintf(fout, "%*s", width_wrap[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
***************
*** 611,711 ****
  				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 */
  
  		if (cancel_pressed)
  			break;
  
  		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;
! 				bool		finalspaces = (opt_border == 2 || j != col_count - 1);
  
! 				if (complete[j])	/* Just print spaces... */
! 				{
! 					if (finalspaces)
! 						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((char *) this_line->ptr);
! 
! 							fprintf(fout, "%*s%s",
! 									(int) (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,
! 						finalspaces ? (widths[j] - this_line->width) : 0, "");
! 					/* 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++;
  		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, widths, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
--- 710,857 ----
  				fputc('\n', fout);
  			}
  
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  		}
  	}
  
  	/* print cells */
  	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
  	{
! 		bool		line_todo,
! 					cols_todo;
! 		int			line_count;
  
  		if (cancel_pressed)
  			break;
  
+ 		/*
+ 		 * Format each cell.  Format again, it is a numeric formatting locale
+ 		 * (e.g. 123,456 vs. 123456)
+ 		 */
  		for (j = 0; j < col_count; j++)
+ 		{
  			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], heights[j]);
+ 			if (opt_numeric_locale && opt_align[j % col_count] == 'r')
+ 			{
+ 				char	   *my_cell;
  
! 				my_cell = format_numeric_locale((char *) col_lineptrs[j]->ptr);
! 				strcpy((char *) col_lineptrs[j]->ptr, my_cell); /* Buffer IS large
! 																 * enough... now */
! 				free(my_cell);
! 			}
! 		}
! 
! 		/* Print rows to console */
  		memset(complete, 0, col_count * sizeof(int));
! 		line_count = 0;
! 		line_todo = true;
! 		while (line_todo)
  		{
! 			cols_todo = true;
! 			while (cols_todo)
  			{
! 				char	border_cell = '*';
  
! 				cols_todo = false;
! 
! 				/* left border */
! 				if (opt_border == 2)
! 					fputs("| ", fout);
! 				else if (opt_border == 1)
! 					fputc(' ', fout);
! 
! 				/* for each column */
! 				for (j = 0; j < col_count; j++)
  				{
! 					struct lineptr *this_line = &col_lineptrs[j][line_count];
! 
! 					if (heights[j] <= line_count)		/* Blank column content */
! 					{
! 						fprintf(fout, "%*s", width_wrap[j], "");
! 						border_cell = '|';
! 					}
! 					else if (opt_align[j] == 'r')		/* Right aligned cell */
  					{
! 						int		strlen_remaining = strlen((char *) this_line->ptr + complete[j]);
! 
! 						if (strlen_remaining > width_wrap[j])
  						{
! 							fprintf(fout, "%.*s", (int) width_wrap[j], this_line->ptr + complete[j]);
! 							complete[j] += width_wrap[j];		/* We've done THIS much */
! 							cols_todo = true;	/* And there is more to do... */
! 							border_cell = ':';
  						}
  						else
! 						{
! 							fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
! 							fprintf(fout, "%-s", this_line->ptr + complete[j]);
! 							complete[j] += strlen_remaining;
! 							border_cell = '|';
! 						}
  					}
! 					else	/* Left aligned cell */
! 					{
! 						int		strlen_remaining = strlen((char *) this_line->ptr + complete[j]);
! 
! 						if (strlen_remaining > width_wrap[j])
! 						{
! 							fprintf(fout, "%.*s", (int) width_wrap[j], this_line->ptr + complete[j]);
! 							complete[j] += width_wrap[j];		/* We've done THIS much */
! 							cols_todo = true;	/* And there is more to do... */
! 							border_cell = ':';
! 						}
! 						else
! 						{
! 							fprintf(fout, "%-s", this_line->ptr + complete[j]);
! 							fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
! 							complete[j] += strlen_remaining;
! 							border_cell = '|';
! 						}
! 					}
! 
! 					/* print a divider, middle of columns only */
! 					if ((j + 1) % col_count)
  					{
! 						if (opt_border == 0)
! 							fputc(' ', fout);
! 						else if (line_count == 0)
! 							fprintf(fout, " %c ", border_cell);
! 						else
! 							fprintf(fout, " %c ", complete[j + 1] ? ' ' : ':');
  					}
  				}
  
! 				/* end of row border */
! 				if (opt_border == 2)
! 					fprintf(fout, " %c", border_cell);
! 				fputc('\n', fout);
! 			}
! 
! 			/*
! 			 * Check if any columns have line continuations due to \n in the
! 			 * cell.
! 			 */
! 			line_count++;
! 			line_todo = false;
! 			for (j = 0; j < col_count; j++)
! 			{
! 				if (line_count < heights[j])
  				{
! 					if (col_lineptrs[j][line_count].ptr)
! 					{
! 						line_todo = true;
! 						complete[j] = 0;
! 					}
  				}
  			}
  		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
***************
*** 722,728 ****
  	}
  
  	/* clean up */
! 	free(widths);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
--- 868,877 ----
  	}
  
  	/* clean up */
! 	free(width_header);
! 	free(width_average);
! 	free(width_max);
! 	free(width_wrap);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
***************
*** 754,760 ****
  				dheight = 1,
  				hformatsize = 0,
  				dformatsize = 0;
- 	int			tmp = 0;
  	char	   *divider;
  	unsigned int cell_count = 0;
  	struct lineptr *hlineptr,
--- 903,908 ----
***************
*** 779,790 ****
  	/* 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)
--- 927,939 ----
  	/* Find the maximum dimensions for the headers */
  	for (i = 0; i < col_count; i++)
  	{
! 		int			width,
! 					height,
  					fs;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &fs);
! 		if (width > hwidth)
! 			hwidth = width;
  		if (height > hheight)
  			hheight = height;
  		if (fs > hformatsize)
***************
*** 799,805 ****
  	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)
--- 948,955 ----
  	for (i = 0, ptr = cells; *ptr; ptr++, i++)
  	{
  		int			numeric_locale_len;
! 		int			width,
! 					height,
  					fs;
  
  		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
***************
*** 807,816 ****
  		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)
--- 957,966 ----
  		else
  			numeric_locale_len = 0;
  
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &fs);
! 		width += numeric_locale_len;
! 		if (width > dwidth)
! 			dwidth = width;
  		if (height > dheight)
  			dheight = height;
  		if (fs > dformatsize)
***************
*** 1879,1884 ****
--- 2029,2035 ----
  									 opt, output);
  			break;
  		case PRINT_ALIGNED:
+ 		case PRINT_WRAP:
  			if (opt->expanded)
  				print_aligned_vertical(title, headers, cells, footers, align,
  									   opt, output);
Index: src/bin/psql/print.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.h,v
retrieving revision 1.35
diff -c -c -r1.35 print.h
*** src/bin/psql/print.h	1 Jan 2008 19:45:56 -0000	1.35
--- src/bin/psql/print.h	17 Apr 2008 14:05:40 -0000
***************
*** 21,26 ****
--- 21,27 ----
  	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
  	PRINT_UNALIGNED,
  	PRINT_ALIGNED,
+ 	PRINT_WRAP,
  	PRINT_HTML,
  	PRINT_LATEX,
  	PRINT_TROFF_MS

/*
 * psql - the PostgreSQL interactive terminal
 *
 * Copyright (c) 2000-2008, PostgreSQL Global Development Group
 *
 * $PostgreSQL: pgsql/src/bin/psql/print.c,v 1.97 2008/03/27 03:57:34 tgl Exp $
 */
#include "postgres_fe.h"

#include "print.h"
#include "catalog/pg_type.h"

#include <math.h>
#include <signal.h>
#include <unistd.h>

#ifndef WIN32
#include <sys/ioctl.h>			/* for ioctl() */
#endif

#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif

#include <locale.h>

#include "pqsignal.h"

#include "mbprint.h"

/*
 * We define the cancel_pressed flag in this file, rather than common.c where
 * it naturally belongs, because this file is also used by non-psql programs
 * (see the bin/scripts/ directory).  In those programs cancel_pressed will
 * never become set and will have no effect.
 *
 * Note: print.c's general strategy for when to check cancel_pressed is to do
 * so at completion of each row of output.
 */
volatile bool cancel_pressed = false;

static char *decimal_point;
static char *grouping;
static char *thousands_sep;

#define COL_RATIO(col_num) \
			((double) width_wrap[col_num] / width_average[col_num] + \
			width_max[col_num] * 0.01)		/* Penalize wide columns */

static void *
pg_local_malloc(size_t size)
{
	void	   *tmp;

	tmp = malloc(size);
	if (!tmp)
	{
		fprintf(stderr, _("out of memory\n"));
		exit(EXIT_FAILURE);
	}
	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)
{
	int			frac_len;

	if (my_str[0] == '-')
		my_str++;

	frac_len = strchr(my_str, '.') ? strlen(strchr(my_str, '.')) : 0;

	return strlen(my_str) - frac_len;
}

/* Return additional length required for locale-aware numeric output */
static int
additional_numeric_locale_len(const char *my_str)
{
	int			int_len = integer_digits(my_str),
				len = 0;
	int			groupdigits = atoi(grouping);

	if (int_len > 0)
		/* Don't count a leading separator */
		len = (int_len / groupdigits - (int_len % groupdigits == 0)) *
			strlen(thousands_sep);

	if (strchr(my_str, '.') != NULL)
		len += strlen(decimal_point) - strlen(".");

	return len;
}

static int
strlen_with_numeric_locale(const char *my_str)
{
	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)
{
	int			i,
				j,
				int_len = integer_digits(my_str),
				leading_digits;
	int			groupdigits = atoi(grouping);
	int			new_str_start = 0;
	char	   *new_str = new_str = pg_local_malloc(
									 strlen_with_numeric_locale(my_str) + 1);

	leading_digits = (int_len % groupdigits != 0) ?
		int_len % groupdigits : groupdigits;

	if (my_str[0] == '-')		/* skip over sign, affects grouping
								 * calculations */
	{
		new_str[0] = my_str[0];
		my_str++;
		new_str_start = 1;
	}

	for (i = 0, j = new_str_start;; i++, j++)
	{
		/* Hit decimal point? */
		if (my_str[i] == '.')
		{
			strcpy(&new_str[j], decimal_point);
			j += strlen(decimal_point);
			/* add fractional part */
			strcpy(&new_str[j], &my_str[i] + 1);
			break;
		}

		/* End of string? */
		if (my_str[i] == '\0')
		{
			new_str[j] = '\0';
			break;
		}

		/* Add separator? */
		if (i != 0 && (i - leading_digits) % groupdigits == 0)
		{
			strcpy(&new_str[j], thousands_sep);
			j += strlen(thousands_sep);
		}

		new_str[j] = my_str[i];
	}

	return new_str;
}

/*************************/
/* Unaligned text		 */
/*************************/


static void
print_unaligned_text(const char *title, const char *const * headers,
					 const char *const * cells, const char *const * footers,
					 const char *opt_align, const printTableOpt *opt,
					 FILE *fout)
{
	const char *opt_fieldsep = opt->fieldSep;
	const char *opt_recordsep = opt->recordSep;
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned int col_count = 0;
	unsigned int i;
	const char *const * ptr;
	bool		need_recordsep = false;

	if (cancel_pressed)
		return;

	if (!opt_fieldsep)
		opt_fieldsep = "";
	if (!opt_recordsep)
		opt_recordsep = "";

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
			fprintf(fout, "%s%s", title, opt_recordsep);

		/* print headers */
		if (!opt_tuples_only)
		{
			for (ptr = headers; *ptr; ptr++)
			{
				if (ptr != headers)
					fputs(opt_fieldsep, fout);
				fputs(*ptr, fout);
			}
			need_recordsep = true;
		}
	}
	else
		/* assume continuing printout */
		need_recordsep = true;

	/* print cells */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		if (need_recordsep)
		{
			fputs(opt_recordsep, fout);
			need_recordsep = false;
			if (cancel_pressed)
				break;
		}
		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			fputs(my_cell, fout);
			free(my_cell);
		}
		else
			fputs(*ptr, fout);

		if ((i + 1) % col_count)
			fputs(opt_fieldsep, fout);
		else
			need_recordsep = true;
	}

	/* print footers */
	if (opt->stop_table)
	{
		if (!opt_tuples_only && footers && !cancel_pressed)
			for (ptr = footers; *ptr; ptr++)
			{
				if (need_recordsep)
				{
					fputs(opt_recordsep, fout);
					need_recordsep = false;
				}
				fputs(*ptr, fout);
				need_recordsep = true;
			}

		/* the last record needs to be concluded with a newline */
		if (need_recordsep)
			fputc('\n', fout);
	}
}


static void
print_unaligned_vertical(const char *title, const char *const * headers,
						 const char *const * cells,
						 const char *const * footers, const char *opt_align,
						 const printTableOpt *opt, FILE *fout)
{
	const char *opt_fieldsep = opt->fieldSep;
	const char *opt_recordsep = opt->recordSep;
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned int col_count = 0;
	unsigned int i;
	const char *const * ptr;
	bool		need_recordsep = false;

	if (cancel_pressed)
		return;

	if (!opt_fieldsep)
		opt_fieldsep = "";
	if (!opt_recordsep)
		opt_recordsep = "";

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs(title, fout);
			need_recordsep = true;
		}
	}
	else
		/* assume continuing printout */
		need_recordsep = true;

	/* print records */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		if (need_recordsep)
		{
			/* record separator is 2 occurrences of recordsep in this mode */
			fputs(opt_recordsep, fout);
			fputs(opt_recordsep, fout);
			need_recordsep = false;
			if (cancel_pressed)
				break;
		}

		fputs(headers[i % col_count], fout);
		fputs(opt_fieldsep, fout);
		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			fputs(my_cell, fout);
			free(my_cell);
		}
		else
			fputs(*ptr, fout);

		if ((i + 1) % col_count)
			fputs(opt_recordsep, fout);
		else
			need_recordsep = true;
	}

	if (opt->stop_table)
	{
		/* print footers */
		if (!opt_tuples_only && footers && *footers && !cancel_pressed)
		{
			fputs(opt_recordsep, fout);
			for (ptr = footers; *ptr; ptr++)
			{
				fputs(opt_recordsep, fout);
				fputs(*ptr, fout);
			}
		}

		fputc('\n', fout);
	}
}


/********************/
/* Aligned text		*/
/********************/


/* draw "line" */
static void
_print_horizontal_line(const unsigned int col_count, const unsigned int *widths, unsigned short border, FILE *fout)
{
	unsigned int i,
				j;

	if (border == 1)
		fputc('-', fout);
	else if (border == 2)
		fputs("+-", fout);

	for (i = 0; i < col_count; i++)
	{
		for (j = 0; j < widths[i]; j++)
			fputc('-', fout);

		if (i < col_count - 1)
		{
			if (border == 0)
				fputc(' ', fout);
			else
				fputs("-+-", fout);
		}
	}

	if (border == 2)
		fputs("-+", fout);
	else if (border == 1)
		fputc('-', fout);

	fputc('\n', fout);
}


/*
 *	Prety pretty boxes around cells.
 */
static void
print_aligned_text(const char *title, const char *const * headers,
				   const char *const * cells, const char *const * footers,
				   const char *opt_align, const printTableOpt *opt,
				   FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	int			encoding = opt->encoding;
	unsigned short int opt_border = opt->border;

	unsigned int col_count = 0, cell_count = 0;

	unsigned int i,
				j;

	unsigned int *width_header,
			   *width_max,
			   *width_wrap,
			   *width_average;
	unsigned int *heights,
			   *format_space;
	unsigned char **format_buf;
	unsigned int width_total;
	unsigned int total_header_width;

	const char *const * ptr;

	struct lineptr **col_lineptrs;		/* pointers to line pointer per column */
	struct lineptr *lineptr_list;		/* complete list of linepointers */

	int		   *complete;		/* Array remembering which columns have
								 * completed output */
	int			tcolumns = 0;	/* Width of interactive console */

	if (cancel_pressed)
		return;

	if (opt_border > 2)
		opt_border = 2;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (col_count > 0)
	{
		width_header = pg_local_calloc(col_count, sizeof(*width_header));
		width_average = pg_local_calloc(col_count, sizeof(*width_average));
		width_max = pg_local_calloc(col_count, sizeof(*width_max));
		width_wrap = pg_local_calloc(col_count, sizeof(*width_wrap));
		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
	{
		width_header = NULL;
		width_average = NULL;
		width_max = NULL;
		width_wrap = NULL;
		heights = NULL;
		col_lineptrs = NULL;
		format_space = NULL;
		format_buf = NULL;
		complete = NULL;
	}

	/* scan all column headers, find maximum width */
	for (i = 0; i < col_count; i++)
	{
		/* Get width & height */
		int			width,
					height,
					space;

		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &space);
		if (width > width_max[i])
			width_max[i] = width;
		if (height > heights[i])
			heights[i] = height;
		if (space > format_space[i])
			format_space[i] = space;

		width_header[i] = width;
	}

	/* scan all rows, find maximum width, compute cell_count */
	for (i = 0, ptr = cells; *ptr; ptr++, i++, cell_count++)
	{
		int			width,
					height,
					space;

		/* Get width, ignore height */
		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &space);
		if (opt_numeric_locale && opt_align[i % col_count] == 'r')
		{
			width += additional_numeric_locale_len(*ptr);
			space += additional_numeric_locale_len(*ptr);
		}

		if (width > width_max[i % col_count])
			width_max[i % col_count] = width;
		if (height > heights[i % col_count])
			heights[i % col_count] = height;
		if (space > format_space[i % col_count])
			format_space[i % col_count] = space;

		width_average[i % col_count] += width;
	}

	/* If we have rows, compute average */
	if (col_count != 0 && cell_count != 0)
	{
		int rows = cell_count / col_count;
		
		for (i = 0; i < col_count; i++)
			width_average[i % col_count] /= rows;
	}

	/* adjust the total display width based on border style */
	if (opt_border == 0)
		width_total = col_count - 1;
	else if (opt_border == 1)
		width_total = col_count * 3 - 1;
	else
		width_total = col_count * 3 + 1;
	total_header_width = width_total;

	for (i = 0; i < col_count; i++) {
		width_total			+= width_max[i];
		total_header_width	+= width_header[i];
		}

	/*
	 * At this point: width_max[] contains the max width of each column,
	 * heights[] contains the max number of lines in each column,
	 * format_space[] contains the maximum storage space for formatting
	 * strings, width_total contains the giant width sum.  Now we allocate
	 * some memory...
	 */
	if (col_count > 0)
	{
		int			height_total = 0;
		struct lineptr *lineptr;

		for (i = 0; i < col_count; i++)
			height_total += heights[i];

		lineptr = lineptr_list = pg_local_calloc(height_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] + 1);

			col_lineptrs[i]->ptr = format_buf[i];
		}
	}
	else
		lineptr_list = NULL;


	/* Default word wrap to the full width, i.e. no word wrap */
	for (i = 0; i < col_count; i++)
		width_wrap[i] = width_max[i];

	/*
	 * Optional optimized word wrap. Shrink columns with a high max/avg ratio.
	 * Slighly bias against wider columns (increases chance a narrow column
	 * will fit in its cell)
	 */
	if (opt->format == PRINT_WRAP)
	{
		/* If we can get the terminal width */
		char	   *env = getenv("COLUMNS");

		if (env != NULL)
			tcolumns = atoi(env);
#ifdef TIOCGWINSZ
		else
		{
			struct winsize screen_size;

			if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
				tcolumns = screen_size.ws_col;
		}
#endif

		/*
		 * If available columns is positive...
		 * and greater than the width of the unshrinkable column headers
		 */
		if (tcolumns > 0 && tcolumns >= total_header_width)
		{
			/* While there is still excess width... */
			while (width_total > tcolumns)
			{
				double		max_ratio = 0, prev_max_ratio = 0;
				double		curr_ratio = 0;
				int			worst_col = -1;

				/*
				 *	Find column that has the highest ratio of its maximum
				 *	width compared to its average width.  This tells us which
				 *	column will produce the fewest wrapped values if shortened.
				 *	width_wrap starts as equal to width_max.
				 */
				for (i = 0; i < col_count; i++)
					if (width_average[i] && width_wrap[i] > width_header[i])
					{
						if (COL_RATIO(i) > max_ratio)
						{
							prev_max_ratio = max_ratio;
							max_ratio = curr_ratio;
							worst_col = i;
						}
					}

				/* Exit loop if we can't squeeze any more. */
				if (worst_col < 0)
					break;

				/* Squeeze the worst column.  Lather, rinse, repeat */
				do
				{
					width_wrap[worst_col]--;
					width_total--;
				} while (width_total > tcolumns && COL_RATIO(i) >= prev_max_ratio);
			}
		}
	}

	/* time to output */
	if (opt->start_table)
	{
		/* print title */
		if (title && !opt_tuples_only)
		{
			int			width,
						height;

			pg_wcssize((unsigned char *) title, strlen(title), encoding, &width, &height, NULL);
			if (width >= width_total)
				fprintf(fout, "%s\n", title);	/* Aligned */
			else
				fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "", title);		/* Centered */
		}

		/* print headers */
		if (!opt_tuples_only)
		{
			int			cols_todo;
			int			line_count;

			if (opt_border == 2)
				_print_horizontal_line(col_count, width_wrap, 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 = width_wrap[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", width_wrap[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, width_wrap, opt_border, fout);
		}
	}

	/* print cells */
	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
	{
		bool		line_todo,
					cols_todo;
		int			line_count;

		if (cancel_pressed)
			break;

		/*
		 * Format each cell.  Format again, it is a numeric formatting locale
		 * (e.g. 123,456 vs. 123456)
		 */
		for (j = 0; j < col_count; j++)
		{
			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], heights[j]);
			if (opt_numeric_locale && opt_align[j % col_count] == 'r')
			{
				char	   *my_cell;

				my_cell = format_numeric_locale((char *) col_lineptrs[j]->ptr);
				strcpy((char *) col_lineptrs[j]->ptr, my_cell); /* Buffer IS large
																 * enough... now */
				free(my_cell);
			}
		}

		/* Print rows to console */
		memset(complete, 0, col_count * sizeof(int));
		line_count = 0;
		line_todo = true;
		while (line_todo)
		{
			cols_todo = true;
			while (cols_todo)
			{
				char	border_cell = '*';

				cols_todo = false;

				/* left border */
				if (opt_border == 2)
					fputs("| ", fout);
				else if (opt_border == 1)
					fputc(' ', fout);

				/* for each column */
				for (j = 0; j < col_count; j++)
				{
					struct lineptr *this_line = &col_lineptrs[j][line_count];

					if (heights[j] <= line_count)		/* Blank column content */
					{
						fprintf(fout, "%*s", width_wrap[j], "");
						border_cell = '|';
					}
					else if (opt_align[j] == 'r')		/* Right aligned cell */
					{
						int		strlen_remaining = strlen((char *) this_line->ptr + complete[j]);

						if (strlen_remaining > width_wrap[j])
						{
							fprintf(fout, "%.*s", (int) width_wrap[j], this_line->ptr + complete[j]);
							complete[j] += width_wrap[j];		/* We've done THIS much */
							cols_todo = true;	/* And there is more to do... */
							border_cell = ':';
						}
						else
						{
							fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
							fprintf(fout, "%-s", this_line->ptr + complete[j]);
							complete[j] += strlen_remaining;
							border_cell = '|';
						}
					}
					else	/* Left aligned cell */
					{
						int		strlen_remaining = strlen((char *) this_line->ptr + complete[j]);

						if (strlen_remaining > width_wrap[j])
						{
							fprintf(fout, "%.*s", (int) width_wrap[j], this_line->ptr + complete[j]);
							complete[j] += width_wrap[j];		/* We've done THIS much */
							cols_todo = true;	/* And there is more to do... */
							border_cell = ':';
						}
						else
						{
							fprintf(fout, "%-s", this_line->ptr + complete[j]);
							fprintf(fout, "%*s", width_wrap[j] - strlen_remaining, "");
							complete[j] += strlen_remaining;
							border_cell = '|';
						}
					}

					/* print a divider, middle of columns only */
					if ((j + 1) % col_count)
					{
						if (opt_border == 0)
							fputc(' ', fout);
						else if (line_count == 0)
							fprintf(fout, " %c ", border_cell);
						else
							fprintf(fout, " %c ", complete[j + 1] ? ' ' : ':');
					}
				}

				/* end of row border */
				if (opt_border == 2)
					fprintf(fout, " %c", border_cell);
				fputc('\n', fout);
			}

			/*
			 * Check if any columns have line continuations due to \n in the
			 * cell.
			 */
			line_count++;
			line_todo = false;
			for (j = 0; j < col_count; j++)
			{
				if (line_count < heights[j])
				{
					if (col_lineptrs[j][line_count].ptr)
					{
						line_todo = true;
						complete[j] = 0;
					}
				}
			}
		}
	}

	if (opt->stop_table)
	{
		if (opt_border == 2 && !cancel_pressed)
			_print_horizontal_line(col_count, width_wrap, opt_border, fout);

		/* print footers */
		if (footers && !opt_tuples_only && !cancel_pressed)
			for (ptr = footers; *ptr; ptr++)
				fprintf(fout, "%s\n", *ptr);

		/*
		 * for some reason MinGW (and MSVC) outputs an extra newline, so this
		 * suppresses it
		 */
#ifndef WIN32
		fputc('\n', fout);
#endif
	}

	/* clean up */
	free(width_header);
	free(width_average);
	free(width_max);
	free(width_wrap);
	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);
}


static void
print_aligned_vertical(const char *title, const char *const * headers,
					   const char *const * cells, const char *const * footers,
					   const char *opt_align, const printTableOpt *opt,
					   FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	int			encoding = opt->encoding;
	unsigned int col_count = 0;
	unsigned long record = opt->prior_records + 1;
	const char *const * ptr;
	unsigned int i,
				hwidth = 0,
				dwidth = 0,
				hheight = 1,
				dheight = 1,
				hformatsize = 0,
				dformatsize = 0;
	char	   *divider;
	unsigned int cell_count = 0;
	struct lineptr *hlineptr,
			   *dlineptr;

	if (cancel_pressed)
		return;

	if (opt_border > 2)
		opt_border = 2;

	if (cells[0] == NULL && opt->start_table && opt->stop_table)
	{
		fprintf(fout, _("(No rows)\n"));
		return;
	}

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	/* Find the maximum dimensions for the headers */
	for (i = 0; i < col_count; i++)
	{
		int			width,
					height,
					fs;

		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &fs);
		if (width > hwidth)
			hwidth = width;
		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			width,
					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, &width, &height, &fs);
		width += numeric_locale_len;
		if (width > dwidth)
			dwidth = width;
		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);

	/* make horizontal border */
	divider = pg_local_malloc(hwidth + dwidth + 10);
	divider[0] = '\0';
	if (opt_border == 2)
		strcat(divider, "+-");
	for (i = 0; i < hwidth; i++)
		strcat(divider, opt_border > 0 ? "-" : " ");
	if (opt_border > 0)
		strcat(divider, "-+-");
	else
		strcat(divider, " ");
	for (i = 0; i < dwidth; i++)
		strcat(divider, opt_border > 0 ? "-" : " ");
	if (opt_border == 2)
		strcat(divider, "-+");

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
			fprintf(fout, "%s\n", title);
	}

	/* print records */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		int			line_count,
					dcomplete,
					hcomplete;

		if (i % col_count == 0)
		{
			if (cancel_pressed)
				break;
			if (!opt_tuples_only)
			{
				char		record_str[64];
				size_t		record_str_len;

				if (opt_border == 0)
					snprintf(record_str, 64, "* Record %lu", record++);
				else
					snprintf(record_str, 64, "[ RECORD %lu ]", record++);
				record_str_len = strlen(record_str);

				if (record_str_len + opt_border > strlen(divider))
					fprintf(fout, "%.*s%s\n", opt_border, divider, record_str);
				else
				{
					char	   *div_copy = strdup(divider);

					if (!div_copy)
					{
						fprintf(stderr, _("out of memory\n"));
						exit(EXIT_FAILURE);
					}

					strncpy(div_copy + opt_border, record_str, record_str_len);
					fprintf(fout, "%s\n", div_copy);
					free(div_copy);
				}
			}
			else if (i != 0 || !opt->start_table || opt_border == 2)
				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((char *) dlineptr[line_count].ptr);

					if (opt_border < 2)
						fprintf(fout, "%s\n", my_cell);
					else
						fprintf(fout, "%-s%*s |\n", my_cell,
								(int) (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->stop_table)
	{
		if (opt_border == 2 && !cancel_pressed)
			fprintf(fout, "%s\n", divider);

		/* print footers */
		if (!opt_tuples_only && footers && *footers && !cancel_pressed)
		{
			if (opt_border < 2)
				fputc('\n', fout);
			for (ptr = footers; *ptr; ptr++)
				fprintf(fout, "%s\n", *ptr);
		}

		fputc('\n', fout);
	}

	free(divider);
	free(hlineptr->ptr);
	free(dlineptr->ptr);
	free(hlineptr);
	free(dlineptr);
}


/**********************/
/* HTML printing ******/
/**********************/


void
html_escaped_print(const char *in, FILE *fout)
{
	const char *p;
	bool		leading_space = true;

	for (p = in; *p; p++)
	{
		switch (*p)
		{
			case '&':
				fputs("&amp;", fout);
				break;
			case '<':
				fputs("&lt;", fout);
				break;
			case '>':
				fputs("&gt;", fout);
				break;
			case '\n':
				fputs("<br />\n", fout);
				break;
			case '"':
				fputs("&quot;", fout);
				break;
			case ' ':
				/* protect leading space, for EXPLAIN output */
				if (leading_space)
					fputs("&nbsp;", fout);
				else
					fputs(" ", fout);
				break;
			default:
				fputc(*p, fout);
		}
		if (*p != ' ')
			leading_space = false;
	}
}


static void
print_html_text(const char *title, const char *const * headers,
				const char *const * cells, const char *const * footers,
				const char *opt_align, const printTableOpt *opt,
				FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	const char *opt_table_attr = opt->tableAttr;
	unsigned int col_count = 0;
	unsigned int i;
	const char *const * ptr;

	if (cancel_pressed)
		return;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		fprintf(fout, "<table border=\"%d\"", opt_border);
		if (opt_table_attr)
			fprintf(fout, " %s", opt_table_attr);
		fputs(">\n", fout);

		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs("  <caption>", fout);
			html_escaped_print(title, fout);
			fputs("</caption>\n", fout);
		}

		/* print headers */
		if (!opt_tuples_only)
		{
			fputs("  <tr>\n", fout);
			for (ptr = headers; *ptr; ptr++)
			{
				fputs("    <th align=\"center\">", fout);
				html_escaped_print(*ptr, fout);
				fputs("</th>\n", fout);
			}
			fputs("  </tr>\n", fout);
		}
	}

	/* print cells */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		if (i % col_count == 0)
		{
			if (cancel_pressed)
				break;
			fputs("  <tr valign=\"top\">\n", fout);
		}

		fprintf(fout, "    <td align=\"%s\">", opt_align[(i) % col_count] == 'r' ? "right" : "left");
		/* is string only whitespace? */
		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
			fputs("&nbsp; ", fout);
		else if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			html_escaped_print(my_cell, fout);
			free(my_cell);
		}
		else
			html_escaped_print(*ptr, fout);

		fputs("</td>\n", fout);

		if ((i + 1) % col_count == 0)
			fputs("  </tr>\n", fout);
	}

	if (opt->stop_table)
	{
		fputs("</table>\n", fout);

		/* print footers */
		if (!opt_tuples_only && footers && *footers && !cancel_pressed)
		{
			fputs("<p>", fout);
			for (ptr = footers; *ptr; ptr++)
			{
				html_escaped_print(*ptr, fout);
				fputs("<br />\n", fout);
			}
			fputs("</p>", fout);
		}

		fputc('\n', fout);
	}
}


static void
print_html_vertical(const char *title, const char *const * headers,
					const char *const * cells, const char *const * footers,
					const char *opt_align, const printTableOpt *opt,
					FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	const char *opt_table_attr = opt->tableAttr;
	unsigned int col_count = 0;
	unsigned long record = opt->prior_records + 1;
	unsigned int i;
	const char *const * ptr;

	if (cancel_pressed)
		return;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		fprintf(fout, "<table border=\"%d\"", opt_border);
		if (opt_table_attr)
			fprintf(fout, " %s", opt_table_attr);
		fputs(">\n", fout);

		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs("  <caption>", fout);
			html_escaped_print(title, fout);
			fputs("</caption>\n", fout);
		}
	}

	/* print records */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		if (i % col_count == 0)
		{
			if (cancel_pressed)
				break;
			if (!opt_tuples_only)
				fprintf(fout,
						"\n  <tr><td colspan=\"2\" align=\"center\">Record %lu</td></tr>\n",
						record++);
			else
				fputs("\n  <tr><td colspan=\"2\">&nbsp;</td></tr>\n", fout);
		}
		fputs("  <tr valign=\"top\">\n"
			  "    <th>", fout);
		html_escaped_print(headers[i % col_count], fout);
		fputs("</th>\n", fout);

		fprintf(fout, "    <td align=\"%s\">", opt_align[i % col_count] == 'r' ? "right" : "left");
		/* is string only whitespace? */
		if ((*ptr)[strspn(*ptr, " \t")] == '\0')
			fputs("&nbsp; ", fout);
		else if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			html_escaped_print(my_cell, fout);
			free(my_cell);
		}
		else
			html_escaped_print(*ptr, fout);

		fputs("</td>\n	</tr>\n", fout);
	}

	if (opt->stop_table)
	{
		fputs("</table>\n", fout);

		/* print footers */
		if (!opt_tuples_only && footers && *footers && !cancel_pressed)
		{
			fputs("<p>", fout);
			for (ptr = footers; *ptr; ptr++)
			{
				html_escaped_print(*ptr, fout);
				fputs("<br />\n", fout);
			}
			fputs("</p>", fout);
		}

		fputc('\n', fout);
	}
}


/*************************/
/* LaTeX				 */
/*************************/


static void
latex_escaped_print(const char *in, FILE *fout)
{
	const char *p;

	for (p = in; *p; p++)
		switch (*p)
		{
			case '&':
				fputs("\\&", fout);
				break;
			case '%':
				fputs("\\%", fout);
				break;
			case '$':
				fputs("\\$", fout);
				break;
			case '_':
				fputs("\\_", fout);
				break;
			case '{':
				fputs("\\{", fout);
				break;
			case '}':
				fputs("\\}", fout);
				break;
			case '\\':
				fputs("\\backslash", fout);
				break;
			case '\n':
				fputs("\\\\", fout);
				break;
			default:
				fputc(*p, fout);
		}
}


static void
print_latex_text(const char *title, const char *const * headers,
				 const char *const * cells, const char *const * footers,
				 const char *opt_align, const printTableOpt *opt,
				 FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	unsigned int col_count = 0;
	unsigned int i;
	const char *const * ptr;

	if (cancel_pressed)
		return;

	if (opt_border > 2)
		opt_border = 2;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs("\\begin{center}\n", fout);
			latex_escaped_print(title, fout);
			fputs("\n\\end{center}\n\n", fout);
		}

		/* begin environment and set alignments and borders */
		fputs("\\begin{tabular}{", fout);

		if (opt_border == 2)
			fputs("| ", fout);
		for (i = 0; i < col_count; i++)
		{
			fputc(*(opt_align + i), fout);
			if (opt_border != 0 && i < col_count - 1)
				fputs(" | ", fout);
		}
		if (opt_border == 2)
			fputs(" |", fout);

		fputs("}\n", fout);

		if (!opt_tuples_only && opt_border == 2)
			fputs("\\hline\n", fout);

		/* print headers */
		if (!opt_tuples_only)
		{
			for (i = 0, ptr = headers; i < col_count; i++, ptr++)
			{
				if (i != 0)
					fputs(" & ", fout);
				fputs("\\textit{", fout);
				latex_escaped_print(*ptr, fout);
				fputc('}', fout);
			}
			fputs(" \\\\\n", fout);
			fputs("\\hline\n", fout);
		}
	}

	/* print cells */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		if (opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			latex_escaped_print(my_cell, fout);
			free(my_cell);
		}
		else
			latex_escaped_print(*ptr, fout);

		if ((i + 1) % col_count == 0)
		{
			fputs(" \\\\\n", fout);
			if (cancel_pressed)
				break;
		}
		else
			fputs(" & ", fout);
	}

	if (opt->stop_table)
	{
		if (opt_border == 2)
			fputs("\\hline\n", fout);

		fputs("\\end{tabular}\n\n\\noindent ", fout);

		/* print footers */
		if (footers && !opt_tuples_only && !cancel_pressed)
		{
			for (ptr = footers; *ptr; ptr++)
			{
				latex_escaped_print(*ptr, fout);
				fputs(" \\\\\n", fout);
			}
		}

		fputc('\n', fout);
	}
}


static void
print_latex_vertical(const char *title, const char *const * headers,
					 const char *const * cells, const char *const * footers,
					 const char *opt_align, const printTableOpt *opt,
					 FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	unsigned int col_count = 0;
	unsigned long record = opt->prior_records + 1;
	unsigned int i;
	const char *const * ptr;

	(void) opt_align;			/* currently unused parameter */

	if (cancel_pressed)
		return;

	if (opt_border > 2)
		opt_border = 2;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs("\\begin{center}\n", fout);
			latex_escaped_print(title, fout);
			fputs("\n\\end{center}\n\n", fout);
		}

		/* begin environment and set alignments and borders */
		fputs("\\begin{tabular}{", fout);
		if (opt_border == 0)
			fputs("cl", fout);
		else if (opt_border == 1)
			fputs("c|l", fout);
		else if (opt_border == 2)
			fputs("|c|l|", fout);
		fputs("}\n", fout);
	}

	/* print records */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		/* new record */
		if (i % col_count == 0)
		{
			if (cancel_pressed)
				break;
			if (!opt_tuples_only)
			{
				if (opt_border == 2)
				{
					fputs("\\hline\n", fout);
					fprintf(fout, "\\multicolumn{2}{|c|}{\\textit{Record %lu}} \\\\\n", record++);
				}
				else
					fprintf(fout, "\\multicolumn{2}{c}{\\textit{Record %lu}} \\\\\n", record++);
			}
			if (opt_border >= 1)
				fputs("\\hline\n", fout);
		}

		latex_escaped_print(headers[i % col_count], fout);
		fputs(" & ", fout);
		latex_escaped_print(*ptr, fout);
		fputs(" \\\\\n", fout);
	}

	if (opt->stop_table)
	{
		if (opt_border == 2)
			fputs("\\hline\n", fout);

		fputs("\\end{tabular}\n\n\\noindent ", fout);

		/* print footers */
		if (footers && !opt_tuples_only && !cancel_pressed)
		{
			for (ptr = footers; *ptr; ptr++)
			{
				if (opt_numeric_locale)
				{
					char	   *my_cell = format_numeric_locale(*ptr);

					latex_escaped_print(my_cell, fout);
					free(my_cell);
				}
				else
					latex_escaped_print(*ptr, fout);
				fputs(" \\\\\n", fout);
			}
		}

		fputc('\n', fout);
	}
}


/*************************/
/* Troff -ms		 */
/*************************/


static void
troff_ms_escaped_print(const char *in, FILE *fout)
{
	const char *p;

	for (p = in; *p; p++)
		switch (*p)
		{
			case '\\':
				fputs("\\(rs", fout);
				break;
			default:
				fputc(*p, fout);
		}
}


static void
print_troff_ms_text(const char *title, const char *const * headers,
					const char *const * cells, const char *const * footers,
					const char *opt_align, const printTableOpt *opt,
					FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	unsigned int col_count = 0;
	unsigned int i;
	const char *const * ptr;

	if (cancel_pressed)
		return;

	if (opt_border > 2)
		opt_border = 2;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs(".LP\n.DS C\n", fout);
			troff_ms_escaped_print(title, fout);
			fputs("\n.DE\n", fout);
		}

		/* begin environment and set alignments and borders */
		fputs(".LP\n.TS\n", fout);
		if (opt_border == 2)
			fputs("center box;\n", fout);
		else
			fputs("center;\n", fout);

		for (i = 0; i < col_count; i++)
		{
			fputc(*(opt_align + i), fout);
			if (opt_border > 0 && i < col_count - 1)
				fputs(" | ", fout);
		}
		fputs(".\n", fout);

		/* print headers */
		if (!opt_tuples_only)
		{
			for (i = 0, ptr = headers; i < col_count; i++, ptr++)
			{
				if (i != 0)
					fputc('\t', fout);
				fputs("\\fI", fout);
				troff_ms_escaped_print(*ptr, fout);
				fputs("\\fP", fout);
			}
			fputs("\n_\n", fout);
		}
	}

	/* print cells */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		if (opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			troff_ms_escaped_print(my_cell, fout);
			free(my_cell);
		}
		else
			troff_ms_escaped_print(*ptr, fout);

		if ((i + 1) % col_count == 0)
		{
			fputc('\n', fout);
			if (cancel_pressed)
				break;
		}
		else
			fputc('\t', fout);
	}

	if (opt->stop_table)
	{
		fputs(".TE\n.DS L\n", fout);

		/* print footers */
		if (footers && !opt_tuples_only && !cancel_pressed)
			for (ptr = footers; *ptr; ptr++)
			{
				troff_ms_escaped_print(*ptr, fout);
				fputc('\n', fout);
			}

		fputs(".DE\n", fout);
	}
}


static void
print_troff_ms_vertical(const char *title, const char *const * headers,
					  const char *const * cells, const char *const * footers,
						const char *opt_align, const printTableOpt *opt,
						FILE *fout)
{
	bool		opt_tuples_only = opt->tuples_only;
	bool		opt_numeric_locale = opt->numericLocale;
	unsigned short int opt_border = opt->border;
	unsigned int col_count = 0;
	unsigned long record = opt->prior_records + 1;
	unsigned int i;
	const char *const * ptr;
	unsigned short current_format = 0;	/* 0=none, 1=header, 2=body */

	(void) opt_align;			/* currently unused parameter */

	if (cancel_pressed)
		return;

	if (opt_border > 2)
		opt_border = 2;

	/* count columns */
	for (ptr = headers; *ptr; ptr++)
		col_count++;

	if (opt->start_table)
	{
		/* print title */
		if (!opt_tuples_only && title)
		{
			fputs(".LP\n.DS C\n", fout);
			troff_ms_escaped_print(title, fout);
			fputs("\n.DE\n", fout);
		}

		/* begin environment and set alignments and borders */
		fputs(".LP\n.TS\n", fout);
		if (opt_border == 2)
			fputs("center box;\n", fout);
		else
			fputs("center;\n", fout);

		/* basic format */
		if (opt_tuples_only)
			fputs("c l;\n", fout);
	}
	else
		current_format = 2;		/* assume tuples printed already */

	/* print records */
	for (i = 0, ptr = cells; *ptr; i++, ptr++)
	{
		/* new record */
		if (i % col_count == 0)
		{
			if (cancel_pressed)
				break;
			if (!opt_tuples_only)
			{
				if (current_format != 1)
				{
					if (opt_border == 2 && record > 1)
						fputs("_\n", fout);
					if (current_format != 0)
						fputs(".T&\n", fout);
					fputs("c s.\n", fout);
					current_format = 1;
				}
				fprintf(fout, "\\fIRecord %lu\\fP\n", record++);
			}
			if (opt_border >= 1)
				fputs("_\n", fout);
		}

		if (!opt_tuples_only)
		{
			if (current_format != 2)
			{
				if (current_format != 0)
					fputs(".T&\n", fout);
				if (opt_border != 1)
					fputs("c l.\n", fout);
				else
					fputs("c | l.\n", fout);
				current_format = 2;
			}
		}

		troff_ms_escaped_print(headers[i % col_count], fout);
		fputc('\t', fout);
		if (opt_numeric_locale)
		{
			char	   *my_cell = format_numeric_locale(*ptr);

			troff_ms_escaped_print(my_cell, fout);
			free(my_cell);
		}
		else
			troff_ms_escaped_print(*ptr, fout);

		fputc('\n', fout);
	}

	if (opt->stop_table)
	{
		fputs(".TE\n.DS L\n", fout);

		/* print footers */
		if (footers && !opt_tuples_only && !cancel_pressed)
			for (ptr = footers; *ptr; ptr++)
			{
				troff_ms_escaped_print(*ptr, fout);
				fputc('\n', fout);
			}

		fputs(".DE\n", fout);
	}
}


/********************************/
/* Public functions		*/
/********************************/


/*
 * PageOutput
 *
 * Tests if pager is needed and returns appropriate FILE pointer.
 */
FILE *
PageOutput(int lines, unsigned short int pager)
{
	/* check whether we need / can / are supposed to use pager */
	if (pager
#ifndef WIN32
		&&
		isatty(fileno(stdin)) &&
		isatty(fileno(stdout))
#endif
		)
	{
		const char *pagerprog;
		FILE	   *pagerpipe;

#ifdef TIOCGWINSZ
		int			result;
		struct winsize screen_size;

		result = ioctl(fileno(stdout), TIOCGWINSZ, &screen_size);

		/* >= accounts for a one-line prompt */
		if (result == -1 || lines >= screen_size.ws_row || pager > 1)
		{
#endif
			pagerprog = getenv("PAGER");
			if (!pagerprog)
				pagerprog = DEFAULT_PAGER;
#ifndef WIN32
			pqsignal(SIGPIPE, SIG_IGN);
#endif
			pagerpipe = popen(pagerprog, "w");
			if (pagerpipe)
				return pagerpipe;
#ifdef TIOCGWINSZ
		}
#endif
	}

	return stdout;
}

/*
 * ClosePager
 *
 * Close previously opened pager pipe, if any
 */
void
ClosePager(FILE *pagerpipe)
{
	if (pagerpipe && pagerpipe != stdout)
	{
		/*
		 * If printing was canceled midstream, warn about it.
		 *
		 * Some pagers like less use Ctrl-C as part of their command set. Even
		 * so, we abort our processing and warn the user what we did.  If the
		 * pager quit as a result of the SIGINT, this message won't go
		 * anywhere ...
		 */
		if (cancel_pressed)
			fprintf(pagerpipe, _("Interrupted\n"));

		pclose(pagerpipe);
#ifndef WIN32
		pqsignal(SIGPIPE, SIG_DFL);
#endif
	}
}


void
printTable(const char *title,
		   const char *const * headers,
		   const char *const * cells,
		   const char *const * footers,
		   const char *align,
		   const printTableOpt *opt, FILE *fout, FILE *flog)
{
	static const char *default_footer[] = {NULL};
	FILE	   *output;

	if (cancel_pressed)
		return;

	if (opt->format == PRINT_NOTHING)
		return;

	if (!footers)
		footers = default_footer;

	if (fout == stdout)
	{
		int			col_count = 0,
					row_count = 0,
					lines;
		const char *const * ptr;

		/* rough estimate of columns and rows */
		if (headers)
			for (ptr = headers; *ptr; ptr++)
				col_count++;
		if (cells)
			for (ptr = cells; *ptr; ptr++)
				row_count++;
		if (col_count > 0)
			row_count /= col_count;

		if (opt->expanded)
			lines = (col_count + 1) * row_count;
		else
			lines = row_count + 1;
		if (footers && !opt->tuples_only)
			for (ptr = footers; *ptr; ptr++)
				lines++;
		output = PageOutput(lines, opt->pager);
	}
	else
		output = fout;

	/* print the stuff */

	if (flog)
		print_aligned_text(title, headers, cells, footers, align,
						   opt, flog);

	switch (opt->format)
	{
		case PRINT_UNALIGNED:
			if (opt->expanded)
				print_unaligned_vertical(title, headers, cells, footers, align,
										 opt, output);
			else
				print_unaligned_text(title, headers, cells, footers, align,
									 opt, output);
			break;
		case PRINT_ALIGNED:
		case PRINT_WRAP:
			if (opt->expanded)
				print_aligned_vertical(title, headers, cells, footers, align,
									   opt, output);
			else
				print_aligned_text(title, headers, cells, footers, align,
								   opt, output);
			break;
		case PRINT_HTML:
			if (opt->expanded)
				print_html_vertical(title, headers, cells, footers, align,
									opt, output);
			else
				print_html_text(title, headers, cells, footers, align,
								opt, output);
			break;
		case PRINT_LATEX:
			if (opt->expanded)
				print_latex_vertical(title, headers, cells, footers, align,
									 opt, output);
			else
				print_latex_text(title, headers, cells, footers, align,
								 opt, output);
			break;
		case PRINT_TROFF_MS:
			if (opt->expanded)
				print_troff_ms_vertical(title, headers, cells, footers, align,
										opt, output);
			else
				print_troff_ms_text(title, headers, cells, footers, align,
									opt, output);
			break;
		default:
			fprintf(stderr, _("invalid output format (internal error): %d"), opt->format);
			exit(EXIT_FAILURE);
	}

	/* Only close if we used the pager */
	if (output != fout)
		ClosePager(output);
}


void
printQuery(const PGresult *result, const printQueryOpt *opt, FILE *fout, FILE *flog)
{
	int			ntuples;
	int			nfields;
	int			ncells;
	const char **headers;
	const char **cells;
	char	  **footers;
	char	   *align;
	int			i,
				r,
				c;

	if (cancel_pressed)
		return;

	/* extract headers */
	ntuples = PQntuples(result);
	nfields = PQnfields(result);

	headers = pg_local_calloc(nfields + 1, sizeof(*headers));

	for (i = 0; i < nfields; i++)
	{
		headers[i] = (char *) mbvalidate((unsigned char *) PQfname(result, i),
										 opt->topt.encoding);
#ifdef ENABLE_NLS
		if (opt->trans_headers)
			headers[i] = _(headers[i]);
#endif
	}

	/* set cells */
	ncells = ntuples * nfields;
	cells = pg_local_calloc(ncells + 1, sizeof(*cells));

	i = 0;
	for (r = 0; r < ntuples; r++)
	{
		for (c = 0; c < nfields; c++)
		{
			if (PQgetisnull(result, r, c))
				cells[i] = opt->nullPrint ? opt->nullPrint : "";
			else
			{
				cells[i] = (char *)
					mbvalidate((unsigned char *) PQgetvalue(result, r, c),
							   opt->topt.encoding);
#ifdef ENABLE_NLS
				if (opt->trans_columns && opt->trans_columns[c])
					cells[i] = _(cells[i]);
#endif
			}
			i++;
		}
	}

	/* set footers */

	if (opt->footers)
		footers = opt->footers;
	else if (!opt->topt.expanded && opt->default_footer)
	{
		unsigned long total_records;

		footers = pg_local_calloc(2, sizeof(*footers));
		footers[0] = pg_local_malloc(100);
		total_records = opt->topt.prior_records + ntuples;
		if (total_records == 1)
			snprintf(footers[0], 100, _("(1 row)"));
		else
			snprintf(footers[0], 100, _("(%lu rows)"), total_records);
	}
	else
		footers = NULL;

	/* set alignment */
	align = pg_local_calloc(nfields + 1, sizeof(*align));

	for (i = 0; i < nfields; i++)
	{
		Oid			ftype = PQftype(result, i);

		switch (ftype)
		{
			case INT2OID:
			case INT4OID:
			case INT8OID:
			case FLOAT4OID:
			case FLOAT8OID:
			case NUMERICOID:
			case OIDOID:
			case XIDOID:
			case CIDOID:
			case CASHOID:
				align[i] = 'r';
				break;
			default:
				align[i] = 'l';
				break;
		}
	}

	/* call table printer */
	printTable(opt->title, headers, cells,
			   (const char *const *) footers,
			   align, &opt->topt, fout, flog);

	free(headers);
	free(cells);
	if (footers && !opt->footers)
	{
		free(footers[0]);
		free(footers);
	}
	free(align);
}


void
setDecimalLocale(void)
{
	struct lconv *extlconv;

	extlconv = localeconv();

	if (*extlconv->decimal_point)
		decimal_point = strdup(extlconv->decimal_point);
	else
		decimal_point = ".";	/* SQL output standard */
	if (*extlconv->grouping && atoi(extlconv->grouping) > 0)
		grouping = strdup(extlconv->grouping);
	else
		grouping = "3";			/* most common */

	/* similar code exists in formatting.c */
	if (*extlconv->thousands_sep)
		thousands_sep = strdup(extlconv->thousands_sep);
	/* Make sure thousands separator doesn't match decimal point symbol. */
	else if (strcmp(decimal_point, ",") != 0)
		thousands_sep = ",";
	else
		thousands_sep = ".";
}

Index: doc/src/sgml/ref/psql-ref.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v
retrieving revision 1.199
diff -c -c -r1.199 psql-ref.sgml
*** doc/src/sgml/ref/psql-ref.sgml	30 Mar 2008 18:10:20 -0000	1.199
--- doc/src/sgml/ref/psql-ref.sgml	20 Apr 2008 03:53:39 -0000
***************
*** 1513,1519 ****
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
--- 1513,1520 ----
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>wrapped</literal>, 
!           <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
***************
*** 1525,1532 ****
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default. The
!           <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
            language. They are not complete documents! (This might not be
--- 1526,1535 ----
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default.
!           <quote>Wrapped</quote> is like <literal>aligned</> but wraps
!           the output to fit the detected screen width or <literal>\pset
!           columns</>.  The <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
            language. They are not complete documents! (This might not be
***************
*** 1537,1542 ****
--- 1540,1556 ----
            </varlistentry>
  
            <varlistentry>
+           <term><literal>columns</literal></term>
+           <listitem>
+           <para>
+           Controls the target width for the <literal>wrap</> format
+           when output is not to the screen, or the operating system does
+           not support screen width detection.
+           </para>
+           </listitem>
+           </varlistentry>
+ 
+           <varlistentry>
            <term><literal>border</literal></term>
            <listitem>
            <para>
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.186
diff -c -c -r1.186 command.c
*** src/bin/psql/command.c	1 Jan 2008 19:45:55 -0000	1.186
--- src/bin/psql/command.c	20 Apr 2008 03:53:39 -0000
***************
*** 1526,1531 ****
--- 1526,1534 ----
  		case PRINT_ALIGNED:
  			return "aligned";
  			break;
+ 		case PRINT_WRAP:
+ 			return "wrapped";
+ 			break;
  		case PRINT_HTML:
  			return "html";
  			break;
***************
*** 1559,1564 ****
--- 1562,1569 ----
  			popt->topt.format = PRINT_UNALIGNED;
  		else if (pg_strncasecmp("aligned", value, vallen) == 0)
  			popt->topt.format = PRINT_ALIGNED;
+ 		else if (pg_strncasecmp("wrapped", value, vallen) == 0)
+ 			popt->topt.format = PRINT_WRAP;
  		else if (pg_strncasecmp("html", value, vallen) == 0)
  			popt->topt.format = PRINT_HTML;
  		else if (pg_strncasecmp("latex", value, vallen) == 0)
***************
*** 1567,1573 ****
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, html, latex, troff-ms\n");
  			return false;
  		}
  
--- 1572,1578 ----
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n");
  			return false;
  		}
  
***************
*** 1748,1753 ****
--- 1753,1768 ----
  		}
  	}
  
+ 	/* set border style/width */
+ 	else if (strcmp(param, "columns") == 0)
+ 	{
+ 		if (value)
+ 			popt->topt.columns = atoi(value);
+ 
+ 		if (!quiet)
+ 			printf(_("Target column width for \"wrap\" format is %d.\n"), popt->topt.columns);
+ 	}
+ 
  	else
  	{
  		psql_error("\\pset: unknown option: %s\n", param);
Index: src/bin/psql/mbprint.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.30
diff -c -c -r1.30 mbprint.c
*** src/bin/psql/mbprint.c	16 Apr 2008 18:18:00 -0000	1.30
--- src/bin/psql/mbprint.c	20 Apr 2008 03:53:41 -0000
***************
*** 204,210 ****
  /*
   * 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_height: Number of lines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
--- 204,210 ----
  /*
   * pg_wcssize takes the given string in the given encoding and returns three
   * values:
!  *	  result_width: Width in display characters of the longest line in string
   *	  result_height: Number of lines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
***************
*** 279,284 ****
--- 279,288 ----
  	return width;
  }
  
+ /*
+  *  Filter out unprintable characters, companion to wcs_size.
+  *  Break input into lines (based on \n or \r).
+  */
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
  			 struct lineptr * lines, int count)
***************
*** 353,364 ****
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';
  	lines->width = linewidth;
! 	lines++;
! 	count--;
! 	if (count > 0)
  		lines->ptr = NULL;
  }
  
  unsigned char *
--- 357,373 ----
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';			/* Terminate formatted string */
! 
  	lines->width = linewidth;
! 
! 	/* Fill remaining array slots with nulls */
! 	while (--count)
! 	{
! 		lines++;			    
  		lines->ptr = NULL;
+ 		lines->width = 0;
+ 	}
  }
  
  unsigned char *
Index: src/bin/psql/print.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.97
diff -c -c -r1.97 print.c
*** src/bin/psql/print.c	27 Mar 2008 03:57:34 -0000	1.97
--- src/bin/psql/print.c	20 Apr 2008 03:53:42 -0000
***************
*** 28,33 ****
--- 28,35 ----
  
  #include "mbprint.h"
  
+ static int mb_strlen_max_width(char *str, int *width, int encoding);
+ 
  /*
   * We define the cancel_pressed flag in this file, rather than common.c where
   * it naturally belongs, because this file is also used by non-psql programs
***************
*** 43,48 ****
--- 45,51 ----
  static char *grouping;
  static char *thousands_sep;
  
+ 
  static void *
  pg_local_malloc(size_t size)
  {
***************
*** 396,401 ****
--- 399,407 ----
  }
  
  
+ /*
+  *	Prety pretty boxes around cells.
+  */
  static void
  print_aligned_text(const char *title, const char *const * headers,
  				   const char *const * cells, const char *const * footers,
***************
*** 404,429 ****
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
- 	unsigned short int opt_border = opt->border;
  	int			encoding = opt->encoding;
! 	unsigned int col_count = 0;
! 	unsigned int cell_count = 0;
! 	unsigned int i;
! 	int			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 */
  
  	if (cancel_pressed)
  		return;
--- 410,441 ----
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
  	int			encoding = opt->encoding;
! 	unsigned short int opt_border = opt->border;
! 
! 	unsigned int col_count = 0, cell_count = 0;
! 
! 	unsigned int i,
! 				j;
! 
! 	unsigned int *width_header,
! 			   *width_max,
! 			   *width_wrap,
! 			   *width_average;
! 	unsigned int *heights,
! 			   *format_space;
  	unsigned char **format_buf;
+ 	unsigned int width_total;
+ 	unsigned int total_header_width;
  
  	const char *const * ptr;
  
! 	struct lineptr **col_lineptrs;		/* pointers to line pointer per column */
  	struct lineptr *lineptr_list;		/* complete list of linepointers */
  
! 	bool	   *header_done;	/* Have all header lines been output? */
! 	int		   *bytes_output;	/* Bytes output for column value */
! 	int			tcolumns = 0;	/* Width of interactive console */
  
  	if (cancel_pressed)
  		return;
***************
*** 437,533 ****
  
  	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)
! 		total_w = col_count - 1;
  	else if (opt_border == 1)
! 		total_w = col_count * 3 - 1;
  	else
! 		total_w = col_count * 3 + 1;
  
  	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
  	 */
  	if (col_count > 0)
  	{
! 		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];
  		}
--- 449,570 ----
  
  	if (col_count > 0)
  	{
! 		width_header = pg_local_calloc(col_count, sizeof(*width_header));
! 		width_average = pg_local_calloc(col_count, sizeof(*width_average));
! 		width_max = pg_local_calloc(col_count, sizeof(*width_max));
! 		width_wrap = pg_local_calloc(col_count, sizeof(*width_wrap));
  		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));
! 		header_done = pg_local_calloc(col_count, sizeof(*header_done));
! 		bytes_output = pg_local_calloc(col_count, sizeof(*bytes_output));
  	}
  	else
  	{
! 		width_header = NULL;
! 		width_average = NULL;
! 		width_max = NULL;
! 		width_wrap = NULL;
  		heights = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
  		format_buf = NULL;
! 		header_done = NULL;
! 		bytes_output = NULL;
  	}
  
! 	/* scan all column headers, find maximum width */
  	for (i = 0; i < col_count; i++)
  	{
  		/* Get width & height */
! 		int			width,
! 					height,
  					space;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &space);
! 		if (width > width_max[i])
! 			width_max[i] = width;
  		if (height > heights[i])
  			heights[i] = height;
  		if (space > format_space[i])
  			format_space[i] = space;
+ 
+ 		width_header[i] = width;
  	}
  
! 	/* scan all rows, find maximum width, compute cell_count */
! 	for (i = 0, ptr = cells; *ptr; ptr++, i++, cell_count++)
  	{
! 		int			width,
! 					height,
  					space;
  
  		/* Get width, ignore height */
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &space);
! 		if (opt_numeric_locale && opt_align[i % col_count] == 'r')
! 		{
! 			width += additional_numeric_locale_len(*ptr);
! 			space += additional_numeric_locale_len(*ptr);
! 		}
! 
! 		if (width > width_max[i % col_count])
! 			width_max[i % col_count] = width;
  		if (height > heights[i % col_count])
  			heights[i % col_count] = height;
  		if (space > format_space[i % col_count])
  			format_space[i % col_count] = space;
+ 
+ 		width_average[i % col_count] += width;
+ 	}
+ 
+ 	/* If we have rows, compute average */
+ 	if (col_count != 0 && cell_count != 0)
+ 	{
+ 		int rows = cell_count / col_count;
+ 		
+ 		for (i = 0; i < col_count; i++)
+ 			width_average[i % col_count] /= rows;
  	}
  
+ 	/* adjust the total display width based on border style */
  	if (opt_border == 0)
! 		width_total = col_count - 1;
  	else if (opt_border == 1)
! 		width_total = col_count * 3 - 1;
  	else
! 		width_total = col_count * 3 + 1;
! 	total_header_width = width_total;
  
  	for (i = 0; i < col_count; i++)
! 	{
! 		width_total += width_max[i];
! 		total_header_width += width_header[i];
! 	}
  
  	/*
! 	 * At this point: width_max[] contains the max width of each column,
! 	 * heights[] contains the max number of lines in each column,
! 	 * format_space[] contains the maximum storage space for formatting
! 	 * strings, width_total contains the giant width sum.  Now we allocate
! 	 * some memory...
  	 */
  	if (col_count > 0)
  	{
! 		int			height_total = 0;
  		struct lineptr *lineptr;
  
  		for (i = 0; i < col_count; i++)
! 			height_total += heights[i];
  
! 		lineptr = lineptr_list = pg_local_calloc(height_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] + 1);
  
  			col_lineptrs[i]->ptr = format_buf[i];
  		}
***************
*** 535,571 ****
  	else
  		lineptr_list = NULL;
  
  	if (opt->start_table)
  	{
  		/* 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
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);
  		}
  
  		/* 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 ? '+' : ' ');
--- 572,678 ----
  	else
  		lineptr_list = NULL;
  
+ 
+ 	/* Default word wrap to the full width, i.e. no word wrap */
+ 	for (i = 0; i < col_count; i++)
+ 		width_wrap[i] = width_max[i];
+ 
+ 	/*
+ 	 * Optional optimized word wrap. Shrink columns with a high max/avg ratio.
+ 	 * Slighly bias against wider columns (increases chance a narrow column
+ 	 * will fit in its cell)
+ 	 */
+ 	if (opt->format == PRINT_WRAP)
+ 	{
+ 		/* Get terminal width */
+ #ifdef TIOCGWINSZ
+ 		if (fout == stdout && isatty(fileno(stdout)))
+ 		{
+ 			struct winsize screen_size;
+ 
+ 			if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
+ 				tcolumns = screen_size.ws_col;
+ 		}
+ 		else
+ #endif
+ 			tcolumns = opt->columns;
+ 
+ 		/*
+ 		 * If available columns is positive...
+ 		 * and greater than the width of the unshrinkable column headers
+ 		 */
+ 		if (tcolumns > 0 && tcolumns >= total_header_width)
+ 		{
+ 			/* While there is still excess width... */
+ 			while (width_total > tcolumns)
+ 			{
+ 				double		max_ratio = 0;
+ 				int			worst_col = -1;
+ 				
+ 				/*
+ 				 *	Find column that has the highest ratio of its maximum
+ 				 *	width compared to its average width.  This tells us which
+ 				 *	column will produce the fewest wrapped values if shortened.
+ 				 *	width_wrap starts as equal to width_max.
+ 				 */
+ 				for (i = 0; i < col_count; i++)
+ 				{
+ 					if (width_average[i] && width_wrap[i] > width_header[i])
+ 					{
+ 						/* Penalize wide columns by +1% of their width (0.01) */
+ 						double ratio = (double)width_wrap[i] / width_average[i] +
+ 									width_max[i] * 0.01;
+ 
+ 						if (ratio > max_ratio)
+ 						{
+ 							max_ratio = ratio;
+ 							worst_col = i;
+ 						}
+ 					}
+ 				}
+ 
+ 				/* Exit loop if we can't squeeze any more. */
+ 				if (worst_col == -1)
+ 					break;
+ 
+ 				width_wrap[worst_col]--;
+ 				width_total--;
+ 			}
+ 		}
+ 	}
+ 
+ 	/* time to output */
  	if (opt->start_table)
  	{
  		/* print title */
  		if (title && !opt_tuples_only)
  		{
! 			int			width,
! 						height;
  
! 			pg_wcssize((unsigned char *) title, strlen(title), encoding, &width, &height, NULL);
! 			if (width >= width_total)
! 				fprintf(fout, "%s\n", title);	/* Aligned */
  			else
! 				fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "", title);		/* Centered */
  		}
  
  		/* print headers */
  		if (!opt_tuples_only)
  		{
! 			int			more_col_wrapping;
  			int			line_count;
  
  			if (opt_border == 2)
! 				_print_horizontal_line(col_count, width_wrap, 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]);
  
! 			more_col_wrapping = col_count;
  			line_count = 0;
! 			memset(header_done, false, col_count * sizeof(bool));
! 			while (more_col_wrapping)
  			{
  				if (opt_border == 2)
  					fprintf(fout, "|%c", line_count ? '+' : ' ');
***************
*** 578,586 ****
  
  					struct lineptr *this_line = col_lineptrs[i] + line_count;
  
! 					if (!complete[i])
  					{
! 						nbspace = widths[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
--- 685,693 ----
  
  					struct lineptr *this_line = col_lineptrs[i] + line_count;
  
! 					if (!header_done[i])
  					{
! 						nbspace = width_wrap[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
***************
*** 588,599 ****
  
  						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)
--- 695,706 ----
  
  						if (line_count == (heights[i] - 1) || !(this_line + 1)->ptr)
  						{
! 							more_col_wrapping--;
! 							header_done[i] = 1;
  						}
  					}
  					else
! 						fprintf(fout, "%*s", width_wrap[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
***************
*** 611,711 ****
  				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 */
  
  		if (cancel_pressed)
  			break;
  
  		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;
! 				bool		finalspaces = (opt_border == 2 || j != col_count - 1);
  
! 				if (complete[j])	/* Just print spaces... */
! 				{
! 					if (finalspaces)
! 						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((char *) this_line->ptr);
! 
! 							fprintf(fout, "%*s%s",
! 									(int) (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,
! 						finalspaces ? (widths[j] - this_line->width) : 0, "");
! 					/* 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++;
! 		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, widths, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
--- 718,877 ----
  				fputc('\n', fout);
  			}
  
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  		}
  	}
  
  	/* print cells */
  	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
  	{
! 		bool		more_newline_values,
! 					more_col_wrapping;
! 		int			line_count = 0, col_line_count;
  
  		if (cancel_pressed)
  			break;
  
+ 		/*
+ 		 * Format each cell.  Format again, it is a numeric formatting locale
+ 		 * (e.g. 123,456 vs. 123456)
+ 		 */
  		for (j = 0; j < col_count; j++)
+ 		{
  			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], heights[j]);
+ 			if (opt_numeric_locale && opt_align[j % col_count] == 'r')
+ 			{
+ 				char	   *my_cell;
  
! 				my_cell = format_numeric_locale((char *) col_lineptrs[j]->ptr);
! 				strcpy((char *) col_lineptrs[j]->ptr, my_cell); /* Buffer IS large
! 																 * enough... now */
! 				free(my_cell);
! 			}
! 		}
  
! 		/* Print rows to console */
! 		memset(bytes_output, 0, col_count * sizeof(int));
! 
! 		do
! 		{
! 			col_line_count = 0;
! 			do
  			{
! 				/* left border */
! 				if (opt_border == 2)
! 					fputs("| ", fout);
! 				else if (opt_border == 1)
! 					fputc(' ', fout);
  
! 				more_col_wrapping = false;
! 
! 				/* for each column */
! 				for (j = 0; j < col_count; j++)
  				{
! 					/* Past column height so pad for other columns */
! 					if (line_count >= heights[j])
! 					{
! 						fprintf(fout, "%*s", width_wrap[j], "");
! 					}
! 					else
  					{
! 						struct lineptr *this_line = &col_lineptrs[j][line_count];
! 						int		bytes_to_output,  chars_to_output = width_wrap[j];
! 
! 						/* Get strlen() of the width_wrap character */
! 						bytes_to_output = mb_strlen_max_width(this_line->ptr +
! 										bytes_output[j], &chars_to_output, encoding);
! 
! 						/* value fills column? */
! 						if (chars_to_output == width_wrap[j])
! 						{
! 							/* If we are filling the column, alignment doesn't matter */
! 
! 							fprintf(fout, "%.*s", (int) bytes_to_output,
! 									this_line->ptr + bytes_output[j]);
! 							bytes_output[j] += bytes_to_output;
! 							/* Is the string done? */
! 							more_col_wrapping = (*(this_line->ptr + bytes_output[j]) != 0);
! 						}
! 						else	/* last line of column value */
  						{
! 							if (opt_align[j] == 'r')		/* Right aligned cell */
! 							{
! 								/* spaces first */
! 								fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
! 								fprintf(fout, "%-s", this_line->ptr + bytes_output[j]);
! 							}
! 							else	/* Left aligned cell */
! 							{
! 								/* spaces second */
! 								fprintf(fout, "%-s", this_line->ptr + bytes_output[j]);
! 								fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
! 							}
! 							bytes_output[j] += bytes_to_output;
  						}
  					}
! 
! 					/* print a divider, middle columns only */
! 					if ((j + 1) % col_count)
  					{
! 						if (opt_border == 0)
! 							fputc(' ', fout);
! 						/* first line for values? */
! 						else if (line_count == 0 && col_line_count == 0)
! 							fputs(" | ", fout);
! 						/* next value is beyond height? */
! 						else if (line_count >= heights[j + 1])
! 							fputs("   ", fout);
! 						/* start of another newline string? */
! 						else if (col_line_count == 0)
! 							fputs(" : ", fout);
! 						else
! 						{
! 							/* does the next column wrap to this line? */
! 							struct lineptr *this_line = &col_lineptrs[j+1][line_count];
! 							bool	string_done = *(this_line->ptr + bytes_output[j+1]) == 0;
! 
! 							fputs(string_done ? "   " : " ; ", fout);
! 						}
  					}
  				}
  
! 				/* end of row border */
! 				if (opt_border == 2)
! 					fputs(" | ", fout);
! 				fputc('\n', fout);
! 				col_line_count++;
! 
! 			} while (more_col_wrapping);
! 
! 			/*
! 			 * Check if any columns have line continuations due to \n in the
! 			 * cell.
! 			 */
! 			line_count++;
! 
! 			/* Do we have more lines for any column value, i.e embedded \n? */
! 			more_newline_values = false;
! 			for (j = 0; j < col_count; j++)
! 			{
! 				if (line_count < heights[j])
  				{
! 					if (col_lineptrs[j][line_count].ptr)
! 					{
! 						more_newline_values = true;
! 						bytes_output[j] = 0;
! 					}
  				}
  			}
! 
! 		} while (more_newline_values);
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
***************
*** 722,732 ****
  	}
  
  	/* 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]);
--- 888,902 ----
  	}
  
  	/* clean up */
! 	free(width_header);
! 	free(width_average);
! 	free(width_max);
! 	free(width_wrap);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
! 	free(header_done);
! 	free(bytes_output);
  	free(lineptr_list);
  	for (i = 0; i < col_count; i++)
  		free(format_buf[i]);
***************
*** 754,760 ****
  				dheight = 1,
  				hformatsize = 0,
  				dformatsize = 0;
- 	int			tmp = 0;
  	char	   *divider;
  	unsigned int cell_count = 0;
  	struct lineptr *hlineptr,
--- 924,929 ----
***************
*** 779,790 ****
  	/* 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)
--- 948,960 ----
  	/* Find the maximum dimensions for the headers */
  	for (i = 0; i < col_count; i++)
  	{
! 		int			width,
! 					height,
  					fs;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &fs);
! 		if (width > hwidth)
! 			hwidth = width;
  		if (height > hheight)
  			hheight = height;
  		if (fs > hformatsize)
***************
*** 799,805 ****
  	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)
--- 969,976 ----
  	for (i = 0, ptr = cells; *ptr; ptr++, i++)
  	{
  		int			numeric_locale_len;
! 		int			width,
! 					height,
  					fs;
  
  		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
***************
*** 807,816 ****
  		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)
--- 978,987 ----
  		else
  			numeric_locale_len = 0;
  
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &fs);
! 		width += numeric_locale_len;
! 		if (width > dwidth)
! 			dwidth = width;
  		if (height > dheight)
  			dheight = height;
  		if (fs > dformatsize)
***************
*** 1879,1884 ****
--- 2050,2056 ----
  									 opt, output);
  			break;
  		case PRINT_ALIGNED:
+ 		case PRINT_WRAP:
  			if (opt->expanded)
  				print_aligned_vertical(title, headers, cells, footers, align,
  									   opt, output);
***************
*** 2066,2068 ****
--- 2238,2262 ----
  	else
  		thousands_sep = ".";
  }
+ 
+ /*
+  *	Returns the byte length to the end of the specified character
+  *  and number of display characters processed (useful if the string
+  *	is shorter then dpylen).
+  */
+ static int
+ mb_strlen_max_width(char *str, int *width, int encoding)
+ {
+ 	int width_left = *width;
+ 	char *start = str;
+ 	
+ 	*width = 0;
+ 	while (*str && width_left--)
+ 	{
+ 		str += PQmblen(str, encoding);
+ 		(*width)++;
+ 	}
+ 
+ 	/* last byte */
+ 	return str - start;
+ }
Index: src/bin/psql/print.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.h,v
retrieving revision 1.35
diff -c -c -r1.35 print.h
*** src/bin/psql/print.h	1 Jan 2008 19:45:56 -0000	1.35
--- src/bin/psql/print.h	20 Apr 2008 03:53:42 -0000
***************
*** 21,26 ****
--- 21,27 ----
  	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
  	PRINT_UNALIGNED,
  	PRINT_ALIGNED,
+ 	PRINT_WRAP,
  	PRINT_HTML,
  	PRINT_LATEX,
  	PRINT_TROFF_MS
***************
*** 47,52 ****
--- 48,54 ----
  								 * decimal marker */
  	char	   *tableAttr;		/* attributes for HTML <table ...> */
  	int			encoding;		/* character encoding */
+ 	int			columns;		/* target width for wrap format */
  } printTableOpt;
  
  

Index: doc/src/sgml/ref/psql-ref.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v
retrieving revision 1.199
diff -c -c -r1.199 psql-ref.sgml
*** doc/src/sgml/ref/psql-ref.sgml	30 Mar 2008 18:10:20 -0000	1.199
--- doc/src/sgml/ref/psql-ref.sgml	21 Apr 2008 15:27:55 -0000
***************
*** 1513,1519 ****
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
--- 1513,1520 ----
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>wrapped</literal>, 
!           <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
***************
*** 1525,1532 ****
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default. The
!           <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
            language. They are not complete documents! (This might not be
--- 1526,1535 ----
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default.
!           <quote>Wrapped</quote> is like <literal>aligned</> but wraps
!           the output to fit the detected screen width or <literal>\pset
!           columns</>.  The <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
            language. They are not complete documents! (This might not be
***************
*** 1537,1542 ****
--- 1540,1556 ----
            </varlistentry>
  
            <varlistentry>
+           <term><literal>columns</literal></term>
+           <listitem>
+           <para>
+           Controls the target width for the <literal>wrap</> format when
+           output is to a file, or the operating system does not support
+           screen width detection.
+           </para>
+           </listitem>
+           </varlistentry>
+ 
+           <varlistentry>
            <term><literal>border</literal></term>
            <listitem>
            <para>
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.186
diff -c -c -r1.186 command.c
*** src/bin/psql/command.c	1 Jan 2008 19:45:55 -0000	1.186
--- src/bin/psql/command.c	21 Apr 2008 15:27:56 -0000
***************
*** 1526,1531 ****
--- 1526,1534 ----
  		case PRINT_ALIGNED:
  			return "aligned";
  			break;
+ 		case PRINT_WRAP:
+ 			return "wrapped";
+ 			break;
  		case PRINT_HTML:
  			return "html";
  			break;
***************
*** 1559,1564 ****
--- 1562,1569 ----
  			popt->topt.format = PRINT_UNALIGNED;
  		else if (pg_strncasecmp("aligned", value, vallen) == 0)
  			popt->topt.format = PRINT_ALIGNED;
+ 		else if (pg_strncasecmp("wrapped", value, vallen) == 0)
+ 			popt->topt.format = PRINT_WRAP;
  		else if (pg_strncasecmp("html", value, vallen) == 0)
  			popt->topt.format = PRINT_HTML;
  		else if (pg_strncasecmp("latex", value, vallen) == 0)
***************
*** 1567,1573 ****
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, html, latex, troff-ms\n");
  			return false;
  		}
  
--- 1572,1578 ----
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n");
  			return false;
  		}
  
***************
*** 1748,1753 ****
--- 1753,1768 ----
  		}
  	}
  
+ 	/* set border style/width */
+ 	else if (strcmp(param, "columns") == 0)
+ 	{
+ 		if (value)
+ 			popt->topt.columns = atoi(value);
+ 
+ 		if (!quiet)
+ 			printf(_("Target column width for \"wrap\" format is %d.\n"), popt->topt.columns);
+ 	}
+ 
  	else
  	{
  		psql_error("\\pset: unknown option: %s\n", param);
Index: src/bin/psql/mbprint.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.30
diff -c -c -r1.30 mbprint.c
*** src/bin/psql/mbprint.c	16 Apr 2008 18:18:00 -0000	1.30
--- src/bin/psql/mbprint.c	21 Apr 2008 15:28:01 -0000
***************
*** 204,210 ****
  /*
   * 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_height: Number of lines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
--- 204,210 ----
  /*
   * pg_wcssize takes the given string in the given encoding and returns three
   * values:
!  *	  result_width: Width in display characters of the longest line in string
   *	  result_height: Number of lines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
***************
*** 279,284 ****
--- 279,288 ----
  	return width;
  }
  
+ /*
+  *  Filter out unprintable characters, companion to wcs_size.
+  *  Break input into lines (based on \n or \r).
+  */
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
  			 struct lineptr * lines, int count)
***************
*** 353,364 ****
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';
  	lines->width = linewidth;
! 	lines++;
! 	count--;
! 	if (count > 0)
  		lines->ptr = NULL;
  }
  
  unsigned char *
--- 357,373 ----
  		}
  		len -= chlen;
  	}
! 	*ptr++ = '\0';			/* Terminate formatted string */
! 
  	lines->width = linewidth;
! 
! 	/* Fill remaining array slots with nulls */
! 	while (--count)
! 	{
! 		lines++;			    
  		lines->ptr = NULL;
+ 		lines->width = 0;
+ 	}
  }
  
  unsigned char *
Index: src/bin/psql/print.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.97
diff -c -c -r1.97 print.c
*** src/bin/psql/print.c	27 Mar 2008 03:57:34 -0000	1.97
--- src/bin/psql/print.c	21 Apr 2008 15:28:02 -0000
***************
*** 28,33 ****
--- 28,35 ----
  
  #include "mbprint.h"
  
+ static int strlen_max_width(unsigned char *str, int *target_width, int encoding);
+ 
  /*
   * We define the cancel_pressed flag in this file, rather than common.c where
   * it naturally belongs, because this file is also used by non-psql programs
***************
*** 43,48 ****
--- 45,51 ----
  static char *grouping;
  static char *thousands_sep;
  
+ 
  static void *
  pg_local_malloc(size_t size)
  {
***************
*** 396,401 ****
--- 399,407 ----
  }
  
  
+ /*
+  *	Prety pretty boxes around cells.
+  */
  static void
  print_aligned_text(const char *title, const char *const * headers,
  				   const char *const * cells, const char *const * footers,
***************
*** 404,429 ****
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
- 	unsigned short int opt_border = opt->border;
  	int			encoding = opt->encoding;
! 	unsigned int col_count = 0;
! 	unsigned int cell_count = 0;
! 	unsigned int i;
! 	int			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 */
  
  	if (cancel_pressed)
  		return;
--- 410,441 ----
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
  	int			encoding = opt->encoding;
! 	unsigned short int opt_border = opt->border;
! 
! 	unsigned int col_count = 0, cell_count = 0;
! 
! 	unsigned int i,
! 				j;
! 
! 	unsigned int *width_header,
! 			   *width_max,
! 			   *width_wrap,
! 			   *width_average;
! 	unsigned int *heights,
! 			   *format_space;
  	unsigned char **format_buf;
+ 	unsigned int width_total;
+ 	unsigned int total_header_width;
  
  	const char *const * ptr;
  
! 	struct lineptr **col_lineptrs;		/* pointers to line pointer per column */
  	struct lineptr *lineptr_list;		/* complete list of linepointers */
  
! 	bool	   *header_done;	/* Have all header lines been output? */
! 	int		   *bytes_output;	/* Bytes output for column value */
! 	int			tcolumns = 0;	/* Width of interactive console */
  
  	if (cancel_pressed)
  		return;
***************
*** 437,533 ****
  
  	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)
! 		total_w = col_count - 1;
  	else if (opt_border == 1)
! 		total_w = col_count * 3 - 1;
  	else
! 		total_w = col_count * 3 + 1;
  
  	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
  	 */
  	if (col_count > 0)
  	{
! 		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];
  		}
--- 449,570 ----
  
  	if (col_count > 0)
  	{
! 		width_header = pg_local_calloc(col_count, sizeof(*width_header));
! 		width_average = pg_local_calloc(col_count, sizeof(*width_average));
! 		width_max = pg_local_calloc(col_count, sizeof(*width_max));
! 		width_wrap = pg_local_calloc(col_count, sizeof(*width_wrap));
  		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));
! 		header_done = pg_local_calloc(col_count, sizeof(*header_done));
! 		bytes_output = pg_local_calloc(col_count, sizeof(*bytes_output));
  	}
  	else
  	{
! 		width_header = NULL;
! 		width_average = NULL;
! 		width_max = NULL;
! 		width_wrap = NULL;
  		heights = NULL;
  		col_lineptrs = NULL;
  		format_space = NULL;
  		format_buf = NULL;
! 		header_done = NULL;
! 		bytes_output = NULL;
  	}
  
! 	/* scan all column headers, find maximum width */
  	for (i = 0; i < col_count; i++)
  	{
  		/* Get width & height */
! 		int			width,
! 					height,
  					space;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &space);
! 		if (width > width_max[i])
! 			width_max[i] = width;
  		if (height > heights[i])
  			heights[i] = height;
  		if (space > format_space[i])
  			format_space[i] = space;
+ 
+ 		width_header[i] = width;
  	}
  
! 	/* scan all rows, find maximum width, compute cell_count */
! 	for (i = 0, ptr = cells; *ptr; ptr++, i++, cell_count++)
  	{
! 		int			width,
! 					height,
  					space;
  
  		/* Get width, ignore height */
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &space);
! 		if (opt_numeric_locale && opt_align[i % col_count] == 'r')
! 		{
! 			width += additional_numeric_locale_len(*ptr);
! 			space += additional_numeric_locale_len(*ptr);
! 		}
! 
! 		if (width > width_max[i % col_count])
! 			width_max[i % col_count] = width;
  		if (height > heights[i % col_count])
  			heights[i % col_count] = height;
  		if (space > format_space[i % col_count])
  			format_space[i % col_count] = space;
+ 
+ 		width_average[i % col_count] += width;
+ 	}
+ 
+ 	/* If we have rows, compute average */
+ 	if (col_count != 0 && cell_count != 0)
+ 	{
+ 		int rows = cell_count / col_count;
+ 		
+ 		for (i = 0; i < col_count; i++)
+ 			width_average[i % col_count] /= rows;
  	}
  
+ 	/* adjust the total display width based on border style */
  	if (opt_border == 0)
! 		width_total = col_count - 1;
  	else if (opt_border == 1)
! 		width_total = col_count * 3 - 1;
  	else
! 		width_total = col_count * 3 + 1;
! 	total_header_width = width_total;
  
  	for (i = 0; i < col_count; i++)
! 	{
! 		width_total += width_max[i];
! 		total_header_width += width_header[i];
! 	}
  
  	/*
! 	 * At this point: width_max[] contains the max width of each column,
! 	 * heights[] contains the max number of lines in each column,
! 	 * format_space[] contains the maximum storage space for formatting
! 	 * strings, width_total contains the giant width sum.  Now we allocate
! 	 * some memory...
  	 */
  	if (col_count > 0)
  	{
! 		int			height_total = 0;
  		struct lineptr *lineptr;
  
  		for (i = 0; i < col_count; i++)
! 			height_total += heights[i];
  
! 		lineptr = lineptr_list = pg_local_calloc(height_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] + 1);
  
  			col_lineptrs[i]->ptr = format_buf[i];
  		}
***************
*** 535,571 ****
  	else
  		lineptr_list = NULL;
  
  	if (opt->start_table)
  	{
  		/* 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
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);
  		}
  
  		/* 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 ? '+' : ' ');
--- 572,678 ----
  	else
  		lineptr_list = NULL;
  
+ 
+ 	/* Default word wrap to the full width, i.e. no word wrap */
+ 	for (i = 0; i < col_count; i++)
+ 		width_wrap[i] = width_max[i];
+ 
+ 	/*
+ 	 * Optional optimized word wrap. Shrink columns with a high max/avg ratio.
+ 	 * Slighly bias against wider columns (increases chance a narrow column
+ 	 * will fit in its cell)
+ 	 */
+ 	if (opt->format == PRINT_WRAP)
+ 	{
+ 		/* Get terminal width */
+ #ifdef TIOCGWINSZ
+ 		if (fout == stdout && isatty(fileno(stdout)))
+ 		{
+ 			struct winsize screen_size;
+ 
+ 			if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
+ 				tcolumns = screen_size.ws_col;
+ 		}
+ 		else
+ #endif
+ 			tcolumns = opt->columns;
+ 
+ 		/*
+ 		 * If available columns is positive...
+ 		 * and greater than the width of the unshrinkable column headers
+ 		 */
+ 		if (tcolumns > 0 && tcolumns >= total_header_width)
+ 		{
+ 			/* While there is still excess width... */
+ 			while (width_total > tcolumns)
+ 			{
+ 				double		max_ratio = 0;
+ 				int			worst_col = -1;
+ 				
+ 				/*
+ 				 *	Find column that has the highest ratio of its maximum
+ 				 *	width compared to its average width.  This tells us which
+ 				 *	column will produce the fewest wrapped values if shortened.
+ 				 *	width_wrap starts as equal to width_max.
+ 				 */
+ 				for (i = 0; i < col_count; i++)
+ 				{
+ 					if (width_average[i] && width_wrap[i] > width_header[i])
+ 					{
+ 						/* Penalize wide columns by +1% of their width (0.01) */
+ 						double ratio = (double)width_wrap[i] / width_average[i] +
+ 									width_max[i] * 0.01;
+ 
+ 						if (ratio > max_ratio)
+ 						{
+ 							max_ratio = ratio;
+ 							worst_col = i;
+ 						}
+ 					}
+ 				}
+ 
+ 				/* Exit loop if we can't squeeze any more. */
+ 				if (worst_col == -1)
+ 					break;
+ 
+ 				width_wrap[worst_col]--;
+ 				width_total--;
+ 			}
+ 		}
+ 	}
+ 
+ 	/* time to output */
  	if (opt->start_table)
  	{
  		/* print title */
  		if (title && !opt_tuples_only)
  		{
! 			int			width,
! 						height;
  
! 			pg_wcssize((unsigned char *) title, strlen(title), encoding, &width, &height, NULL);
! 			if (width >= width_total)
! 				fprintf(fout, "%s\n", title);	/* Aligned */
  			else
! 				fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "", title);		/* Centered */
  		}
  
  		/* print headers */
  		if (!opt_tuples_only)
  		{
! 			int			more_col_wrapping;
  			int			line_count;
  
  			if (opt_border == 2)
! 				_print_horizontal_line(col_count, width_wrap, 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]);
  
! 			more_col_wrapping = col_count;
  			line_count = 0;
! 			memset(header_done, false, col_count * sizeof(bool));
! 			while (more_col_wrapping)
  			{
  				if (opt_border == 2)
  					fprintf(fout, "|%c", line_count ? '+' : ' ');
***************
*** 578,586 ****
  
  					struct lineptr *this_line = col_lineptrs[i] + line_count;
  
! 					if (!complete[i])
  					{
! 						nbspace = widths[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
--- 685,693 ----
  
  					struct lineptr *this_line = col_lineptrs[i] + line_count;
  
! 					if (!header_done[i])
  					{
! 						nbspace = width_wrap[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
***************
*** 588,599 ****
  
  						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)
--- 695,706 ----
  
  						if (line_count == (heights[i] - 1) || !(this_line + 1)->ptr)
  						{
! 							more_col_wrapping--;
! 							header_done[i] = 1;
  						}
  					}
  					else
! 						fprintf(fout, "%*s", width_wrap[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
***************
*** 607,711 ****
  				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 */
  
  		if (cancel_pressed)
  			break;
  
  		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;
! 				bool		finalspaces = (opt_border == 2 || j != col_count - 1);
  
! 				if (complete[j])	/* Just print spaces... */
! 				{
! 					if (finalspaces)
! 						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((char *) this_line->ptr);
! 
! 							fprintf(fout, "%*s%s",
! 									(int) (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,
! 						finalspaces ? (widths[j] - this_line->width) : 0, "");
! 					/* 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++;
! 		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, widths, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
--- 714,877 ----
  				if (opt_border == 2)
  					fputs(" |", fout);
  				else if (opt_border == 1)
! 					fputc(' ', fout);
  				fputc('\n', fout);
  			}
  
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  		}
  	}
  
  	/* print cells */
  	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
  	{
! 		bool		more_newline_values,
! 					more_col_wrapping;
! 		int			line_count = 0, col_line_count;
  
  		if (cancel_pressed)
  			break;
  
+ 		/*
+ 		 * Format each cell.  Format again, it is a numeric formatting locale
+ 		 * (e.g. 123,456 vs. 123456)
+ 		 */
  		for (j = 0; j < col_count; j++)
+ 		{
  			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], heights[j]);
+ 			if (opt_numeric_locale && opt_align[j % col_count] == 'r')
+ 			{
+ 				char	   *my_cell;
  
! 				my_cell = format_numeric_locale((char *) col_lineptrs[j]->ptr);
! 				strcpy((char *) col_lineptrs[j]->ptr, my_cell); /* Buffer IS large
! 																 * enough... now */
! 				free(my_cell);
! 			}
! 		}
  
! 		/* Print rows to console */
! 		memset(bytes_output, 0, col_count * sizeof(int));
! 
! 		do
! 		{
! 			col_line_count = 0;
! 			do
  			{
! 				/* left border */
! 				if (opt_border == 2)
! 					fputs("| ", fout);
! 				else if (opt_border == 1)
! 					fputc(' ', fout);
  
! 				more_col_wrapping = false;
! 
! 				/* for each column */
! 				for (j = 0; j < col_count; j++)
  				{
! 					/* Past column height so pad for other columns */
! 					if (line_count >= heights[j])
! 						fprintf(fout, "%*s", width_wrap[j], "");
! 					else
  					{
! 						struct lineptr *this_line = &col_lineptrs[j][line_count];
! 						int		bytes_to_output,  chars_to_output = width_wrap[j];
! 
! 						/* Get strlen() of the width_wrap character */
! 						bytes_to_output = strlen_max_width(this_line->ptr +
! 										bytes_output[j], &chars_to_output, encoding);
! 
! 						/*
! 						 *	If we exceeded width_wrap, it means the display width
! 						 *	of a single character was wider than our target width.
! 						 *	In that case, we have to pretend we are only printing
! 						 *	the target display width and make the best of it.
! 						 */
! 						if (chars_to_output > width_wrap[j])
! 							chars_to_output = width_wrap[j];
! 
! 						if (opt_align[j] == 'r')		/* Right aligned cell */
  						{
! 							/* spaces first */
! 							fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
! 							fprintf(fout, "%.*s", bytes_to_output,
! 									this_line->ptr + bytes_output[j]);
  						}
! 						else	/* Left aligned cell */
! 						{
! 							/* spaces second */
! 							fprintf(fout, "%.*s", bytes_to_output,
! 									this_line->ptr + bytes_output[j]);
! 							fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
! 						}
! 
! 						bytes_output[j] += bytes_to_output;
! 
! 						/* Are we at the end of the string? */
! 						more_col_wrapping = more_col_wrapping ||
! 							(*(this_line->ptr + bytes_output[j]) != 0);
  					}
! 
! 					/* print a divider, middle columns only */
! 					if ((j + 1) % col_count)
  					{
! 						if (opt_border == 0)
! 							fputc(' ', fout);
! 						/* first line for values? */
! 						else if (line_count == 0 && col_line_count == 0)
! 							fputs(" | ", fout);
! 						/* next value is beyond height? */
! 						else if (line_count >= heights[j + 1])
! 							fputs("   ", fout);
! 						/* start of another newline string? */
! 						else if (col_line_count == 0)
! 							fputs(" : ", fout);
! 						else
! 						{
! 							/* Does the next column wrap to this line? */
! 							struct lineptr *this_line = &col_lineptrs[j+1][line_count];
! 							bool	string_done = *(this_line->ptr + bytes_output[j+1]) == 0;
! 
! 							fputs(string_done ? "   " : " ; ", fout);
! 						}
  					}
  				}
  
! 				/* end of row border */
! 				if (opt_border == 2)
! 					fputs(" |", fout);
! 				fputc('\n', fout);
! 				col_line_count++;
! 
! 			} while (more_col_wrapping);
! 
! 			/*
! 			 * Check if any columns have line continuations due to \n in the
! 			 * cell.
! 			 */
! 			line_count++;
! 
! 			/* Do we have more lines for any column value, i.e embedded \n? */
! 			more_newline_values = false;
! 			for (j = 0; j < col_count; j++)
! 			{
! 				if (line_count < heights[j])
  				{
! 					if (col_lineptrs[j][line_count].ptr)
! 					{
! 						more_newline_values = true;
! 						bytes_output[j] = 0;
! 					}
  				}
  			}
! 
! 		} while (more_newline_values);
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
***************
*** 722,732 ****
  	}
  
  	/* 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]);
--- 888,902 ----
  	}
  
  	/* clean up */
! 	free(width_header);
! 	free(width_average);
! 	free(width_max);
! 	free(width_wrap);
  	free(heights);
  	free(col_lineptrs);
  	free(format_space);
! 	free(header_done);
! 	free(bytes_output);
  	free(lineptr_list);
  	for (i = 0; i < col_count; i++)
  		free(format_buf[i]);
***************
*** 754,760 ****
  				dheight = 1,
  				hformatsize = 0,
  				dformatsize = 0;
- 	int			tmp = 0;
  	char	   *divider;
  	unsigned int cell_count = 0;
  	struct lineptr *hlineptr,
--- 924,929 ----
***************
*** 779,790 ****
  	/* 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)
--- 948,960 ----
  	/* Find the maximum dimensions for the headers */
  	for (i = 0; i < col_count; i++)
  	{
! 		int			width,
! 					height,
  					fs;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &fs);
! 		if (width > hwidth)
! 			hwidth = width;
  		if (height > hheight)
  			hheight = height;
  		if (fs > hformatsize)
***************
*** 799,805 ****
  	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)
--- 969,976 ----
  	for (i = 0, ptr = cells; *ptr; ptr++, i++)
  	{
  		int			numeric_locale_len;
! 		int			width,
! 					height,
  					fs;
  
  		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
***************
*** 807,816 ****
  		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)
--- 978,987 ----
  		else
  			numeric_locale_len = 0;
  
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &fs);
! 		width += numeric_locale_len;
! 		if (width > dwidth)
! 			dwidth = width;
  		if (height > dheight)
  			dheight = height;
  		if (fs > dformatsize)
***************
*** 1879,1884 ****
--- 2050,2056 ----
  									 opt, output);
  			break;
  		case PRINT_ALIGNED:
+ 		case PRINT_WRAP:
  			if (opt->expanded)
  				print_aligned_vertical(title, headers, cells, footers, align,
  									   opt, output);
***************
*** 2066,2068 ****
--- 2238,2275 ----
  	else
  		thousands_sep = ".";
  }
+ 
+ /*
+  *	Returns the byte length to the end of the specified character
+  *  and number of display characters processed (useful if the string
+  *	is shorter then dpylen).
+  */
+ static int
+ strlen_max_width(unsigned char *str, int *target_width, int encoding)
+ {
+ 	unsigned char *start = str;
+ 	int curr_width = 0;
+ 
+ 	while (*str && curr_width < *target_width)
+ 	{
+ 		int char_width = PQdsplen((char *) str, encoding);
+ 
+ 		/*
+ 		 *	If the display width of the new character causes
+ 		 *	the string to exceed its target width, skip it
+ 		 *	and return.  However, if this is the first character
+ 		 *	of the string (*width == 0), we have to accept it.
+ 		 */
+ 		if (*target_width - curr_width < char_width && curr_width != 0)
+ 			break;
+ 			
+ 		str += PQmblen((char *)str, encoding);
+ 
+ 		curr_width += char_width;
+ 	}
+ 
+ 	*target_width = curr_width;
+ 	
+ 	/* last byte */
+ 	return str - start;
+ }
Index: src/bin/psql/print.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.h,v
retrieving revision 1.35
diff -c -c -r1.35 print.h
*** src/bin/psql/print.h	1 Jan 2008 19:45:56 -0000	1.35
--- src/bin/psql/print.h	21 Apr 2008 15:28:02 -0000
***************
*** 21,26 ****
--- 21,27 ----
  	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
  	PRINT_UNALIGNED,
  	PRINT_ALIGNED,
+ 	PRINT_WRAP,
  	PRINT_HTML,
  	PRINT_LATEX,
  	PRINT_TROFF_MS
***************
*** 47,52 ****
--- 48,54 ----
  								 * decimal marker */
  	char	   *tableAttr;		/* attributes for HTML <table ...> */
  	int			encoding;		/* character encoding */
+ 	int			columns;		/* target width for wrap format */
  } printTableOpt;
  
  

Index: doc/src/sgml/ref/psql-ref.sgml
===================================================================
RCS file: /cvsroot/pgsql/doc/src/sgml/ref/psql-ref.sgml,v
retrieving revision 1.199
diff -c -c -r1.199 psql-ref.sgml
*** doc/src/sgml/ref/psql-ref.sgml	30 Mar 2008 18:10:20 -0000	1.199
--- doc/src/sgml/ref/psql-ref.sgml	29 Apr 2008 01:24:44 -0000
***************
*** 1513,1519 ****
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
--- 1513,1520 ----
            <listitem>
            <para>
            Sets the output format to one of <literal>unaligned</literal>,
!           <literal>aligned</literal>, <literal>wrapped</literal>, 
!           <literal>html</literal>,
            <literal>latex</literal>, or <literal>troff-ms</literal>.
            Unique abbreviations are allowed.  (That would mean one letter
            is enough.)
***************
*** 1525,1531 ****
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default. The
            <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
--- 1526,1535 ----
            is intended to create output that might be intended to be read
            in by other programs (tab-separated, comma-separated).
            <quote>Aligned</quote> mode is the standard, human-readable,
!           nicely formatted text output that is default.
!           <quote>Wrapped</quote> is like <literal>aligned</> but wraps
!           to a target width of <literal>\pset columns</> or the
!           width of the screen.  The
            <quote><acronym>HTML</acronym></quote> and
            <quote>LaTeX</quote> modes put out tables that are intended to
            be included in documents using the respective mark-up
***************
*** 1537,1542 ****
--- 1541,1557 ----
            </varlistentry>
  
            <varlistentry>
+           <term><literal>columns</literal></term>
+           <listitem>
+           <para>
+           Controls the target width for the <literal>wrapped</> format.
+           Zero (the default) causes the <literal>wrapped</> format to
+           affect only screen output.
+           </para>
+           </listitem>
+           </varlistentry>
+ 
+           <varlistentry>
            <term><literal>border</literal></term>
            <listitem>
            <para>
***************
*** 2707,2712 ****
--- 2722,2739 ----
    <title>Environment</title>
  
    <variablelist>
+ 
+    <varlistentry>
+     <term><envar>COLUMNS</envar></term>
+ 
+     <listitem>
+      <para>
+       Used for the <literal>wrapped</> format when screen width
+       detection fails.
+      </para>
+     </listitem>
+    </varlistentry>
+ 
     <varlistentry>
      <term><envar>PAGER</envar></term>
  
Index: src/bin/psql/command.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/command.c,v
retrieving revision 1.186
diff -c -c -r1.186 command.c
*** src/bin/psql/command.c	1 Jan 2008 19:45:55 -0000	1.186
--- src/bin/psql/command.c	29 Apr 2008 01:24:45 -0000
***************
*** 1526,1531 ****
--- 1526,1534 ----
  		case PRINT_ALIGNED:
  			return "aligned";
  			break;
+ 		case PRINT_WRAPPED:
+ 			return "wrapped";
+ 			break;
  		case PRINT_HTML:
  			return "html";
  			break;
***************
*** 1559,1564 ****
--- 1562,1569 ----
  			popt->topt.format = PRINT_UNALIGNED;
  		else if (pg_strncasecmp("aligned", value, vallen) == 0)
  			popt->topt.format = PRINT_ALIGNED;
+ 		else if (pg_strncasecmp("wrapped", value, vallen) == 0)
+ 			popt->topt.format = PRINT_WRAPPED;
  		else if (pg_strncasecmp("html", value, vallen) == 0)
  			popt->topt.format = PRINT_HTML;
  		else if (pg_strncasecmp("latex", value, vallen) == 0)
***************
*** 1567,1573 ****
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, html, latex, troff-ms\n");
  			return false;
  		}
  
--- 1572,1578 ----
  			popt->topt.format = PRINT_TROFF_MS;
  		else
  		{
! 			psql_error("\\pset: allowed formats are unaligned, aligned, wrapped, html, latex, troff-ms\n");
  			return false;
  		}
  
***************
*** 1748,1753 ****
--- 1753,1768 ----
  		}
  	}
  
+ 	/* set border style/width */
+ 	else if (strcmp(param, "columns") == 0)
+ 	{
+ 		if (value)
+ 			popt->topt.columns = atoi(value);
+ 
+ 		if (!quiet)
+ 			printf(_("Target width for \"wrapped\" format is %d.\n"), popt->topt.columns);
+ 	}
+ 
  	else
  	{
  		psql_error("\\pset: unknown option: %s\n", param);
Index: src/bin/psql/mbprint.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/mbprint.c,v
retrieving revision 1.30
diff -c -c -r1.30 mbprint.c
*** src/bin/psql/mbprint.c	16 Apr 2008 18:18:00 -0000	1.30
--- src/bin/psql/mbprint.c	29 Apr 2008 01:24:47 -0000
***************
*** 204,211 ****
  /*
   * 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_height: Number of lines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
  int
--- 204,211 ----
  /*
   * pg_wcssize takes the given string in the given encoding and returns three
   * values:
!  *	  result_width: Width in display characters of the longest line in string
!  *	  result_height: Number of newlines in display output
   *	  result_format_size: Number of bytes required to store formatted representation of string
   */
  int
***************
*** 279,287 ****
  	return width;
  }
  
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
! 			 struct lineptr * lines, int count)
  {
  	int			w,
  				chlen = 0;
--- 279,292 ----
  	return width;
  }
  
+ /*
+  *  Filter out unprintable characters, companion to wcs_size.
+  *  Break input into lines based on \n.  lineptr[i].ptr == NULL
+  *	indicates the end of the array.
+  */
  void
  pg_wcsformat(unsigned char *pwcs, size_t len, int encoding,
! 			 struct lineptr *lines, int count)
  {
  	int			w,
  				chlen = 0;
***************
*** 307,312 ****
--- 312,318 ----
  				if (count == 0)
  					exit(1);	/* Screwup */
  
+ 				/* make next line point to remaining memory */
  				lines->ptr = ptr;
  			}
  			else if (*pwcs == '\r')		/* Linefeed */
***************
*** 353,364 ****
  		}
  		len -= chlen;
  	}
- 	*ptr++ = '\0';
  	lines->width = linewidth;
! 	lines++;
! 	count--;
! 	if (count > 0)
! 		lines->ptr = NULL;
  }
  
  unsigned char *
--- 359,371 ----
  		}
  		len -= chlen;
  	}
  	lines->width = linewidth;
! 	*ptr++ = '\0';			/* Terminate formatted string */
! 
! 	if (count == 0)
! 		exit(1);	/* Screwup */
! 
! 	(lines+1)->ptr = NULL;	/* terminate line array */
  }
  
  unsigned char *
Index: src/bin/psql/print.c
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.c,v
retrieving revision 1.97
diff -c -c -r1.97 print.c
*** src/bin/psql/print.c	27 Mar 2008 03:57:34 -0000	1.97
--- src/bin/psql/print.c	29 Apr 2008 01:24:48 -0000
***************
*** 28,33 ****
--- 28,35 ----
  
  #include "mbprint.h"
  
+ static int strlen_max_width(unsigned char *str, int *target_width, int encoding);
+ 
  /*
   * We define the cancel_pressed flag in this file, rather than common.c where
   * it naturally belongs, because this file is also used by non-psql programs
***************
*** 43,48 ****
--- 45,51 ----
  static char *grouping;
  static char *thousands_sep;
  
+ 
  static void *
  pg_local_malloc(size_t size)
  {
***************
*** 396,401 ****
--- 399,407 ----
  }
  
  
+ /*
+  *	Prety pretty boxes around cells.
+  */
  static void
  print_aligned_text(const char *title, const char *const * headers,
  				   const char *const * cells, const char *const * footers,
***************
*** 404,429 ****
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
- 	unsigned short int opt_border = opt->border;
  	int			encoding = opt->encoding;
! 	unsigned int col_count = 0;
! 	unsigned int cell_count = 0;
! 	unsigned int i;
! 	int			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 */
  
  	if (cancel_pressed)
  		return;
--- 410,441 ----
  {
  	bool		opt_tuples_only = opt->tuples_only;
  	bool		opt_numeric_locale = opt->numericLocale;
  	int			encoding = opt->encoding;
! 	unsigned short int opt_border = opt->border;
! 
! 	unsigned int col_count = 0, cell_count = 0;
! 
! 	unsigned int i,
! 				j;
! 
! 	unsigned int *width_header,
! 			   *max_width,
! 			   *width_wrap,
! 			   *width_average;
! 	unsigned int *max_nl_lines,	/* value split by newlines */
! 				*curr_nl_line,
! 				*max_bytes;
  	unsigned char **format_buf;
+ 	unsigned int width_total;
+ 	unsigned int total_header_width;
  
! 	const char * const *ptr;
  
! 	struct lineptr **col_lineptrs;		/* pointers to line pointer per column */
  
! 	bool	   *header_done;	/* Have all header lines been output? */
! 	int		   *bytes_output;	/* Bytes output for column value */
! 	int			output_columns = 0;	/* Width of interactive console */
  
  	if (cancel_pressed)
  		return;
***************
*** 437,711 ****
  
  	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)
! 		total_w = col_count - 1;
  	else if (opt_border == 1)
! 		total_w = col_count * 3 - 1;
  	else
! 		total_w = col_count * 3 + 1;
  
  	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
  	 */
! 	if (col_count > 0)
  	{
! 		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];
  		}
  	}
- 	else
- 		lineptr_list = NULL;
  
  	if (opt->start_table)
  	{
  		/* 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
! 				fprintf(fout, "%-*s%s\n", (total_w - tmp) / 2, "", title);
  		}
  
  		/* 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 */
  
  		if (cancel_pressed)
  			break;
  
  		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;
! 				bool		finalspaces = (opt_border == 2 || j != col_count - 1);
! 
! 				if (complete[j])	/* Just print spaces... */
! 				{
! 					if (finalspaces)
! 						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((char *) this_line->ptr);
! 
! 							fprintf(fout, "%*s%s",
! 									(int) (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,
- 						finalspaces ? (widths[j] - this_line->width) : 0, "");
- 					/* 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++;
! 		}
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, widths, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
--- 449,856 ----
  
  	if (col_count > 0)
  	{
! 		width_header = pg_local_calloc(col_count, sizeof(*width_header));
! 		width_average = pg_local_calloc(col_count, sizeof(*width_average));
! 		max_width = pg_local_calloc(col_count, sizeof(*max_width));
! 		width_wrap = pg_local_calloc(col_count, sizeof(*width_wrap));
! 		max_nl_lines = pg_local_calloc(col_count, sizeof(*max_nl_lines));
! 		curr_nl_line = pg_local_calloc(col_count, sizeof(*curr_nl_line));
  		col_lineptrs = pg_local_calloc(col_count, sizeof(*col_lineptrs));
! 		max_bytes = pg_local_calloc(col_count, sizeof(*max_bytes));
  		format_buf = pg_local_calloc(col_count, sizeof(*format_buf));
! 		header_done = pg_local_calloc(col_count, sizeof(*header_done));
! 		bytes_output = pg_local_calloc(col_count, sizeof(*bytes_output));
  	}
  	else
  	{
! 		width_header = NULL;
! 		width_average = NULL;
! 		max_width = NULL;
! 		width_wrap = NULL;
! 		max_nl_lines = NULL;
! 		curr_nl_line = NULL;
  		col_lineptrs = NULL;
! 		max_bytes = NULL;
  		format_buf = NULL;
! 		header_done = NULL;
! 		bytes_output = NULL;
  	}
  
! 	/* scan all column headers, find maximum width and max max_nl_lines */
  	for (i = 0; i < col_count; i++)
  	{
! 		int			width,
! 					nl_lines,
! 					bytes_required;
! 
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &nl_lines, &bytes_required);
! 		if (width > max_width[i])
! 			max_width[i] = width;
! 		if (nl_lines > max_nl_lines[i])
! 			max_nl_lines[i] = nl_lines;
! 		if (bytes_required > max_bytes[i])
! 			max_bytes[i] = bytes_required;
! 
! 		width_header[i] = width;
  	}
  
! 	/* scan all cells, find maximum width, compute cell_count */
! 	for (i = 0, ptr = cells; *ptr; ptr++, i++, cell_count++)
  	{
! 		int			width,
! 					nl_lines,
! 					bytes_required;
  
! 		/* Get width, ignore nl_lines */
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &nl_lines, &bytes_required);
! 		if (opt_numeric_locale && opt_align[i % col_count] == 'r')
! 		{
! 			width += additional_numeric_locale_len(*ptr);
! 			bytes_required += additional_numeric_locale_len(*ptr);
! 		}
! 
! 		if (width > max_width[i % col_count])
! 			max_width[i % col_count] = width;
! 		if (nl_lines > max_nl_lines[i % col_count])
! 			max_nl_lines[i % col_count] = nl_lines;
! 		if (bytes_required > max_bytes[i % col_count])
! 			max_bytes[i % col_count] = bytes_required;
  
! 		width_average[i % col_count] += width;
  	}
  
+ 	/* If we have rows, compute average */
+ 	if (col_count != 0 && cell_count != 0)
+ 	{
+ 		int rows = cell_count / col_count;
+ 		
+ 		for (i = 0; i < col_count; i++)
+ 			width_average[i % col_count] /= rows;
+ 	}
+ 
+ 	/* adjust the total display width based on border style */
  	if (opt_border == 0)
! 		width_total = col_count - 1;
  	else if (opt_border == 1)
! 		width_total = col_count * 3 - 1;
  	else
! 		width_total = col_count * 3 + 1;
! 	total_header_width = width_total;
  
  	for (i = 0; i < col_count; i++)
! 	{
! 		width_total += max_width[i];
! 		total_header_width += width_header[i];
! 	}
  
  	/*
! 	 * At this point: max_width[] contains the max width of each column,
! 	 * max_nl_lines[] contains the max number of lines in each column,
! 	 * max_bytes[] contains the maximum storage space for formatting
! 	 * strings, width_total contains the giant width sum.  Now we allocate
! 	 * some memory for line pointers.
  	 */
! 	for (i = 0; i < col_count; i++)
  	{
! 		/* Add entry for ptr == NULL array termination */
! 		col_lineptrs[i] = pg_local_calloc(max_nl_lines[i] + 1,
! 											sizeof(**col_lineptrs));
  
! 		format_buf[i] = pg_local_malloc(max_bytes[i] + 1);
  
! 		col_lineptrs[i]->ptr = format_buf[i];
! 	}
  
! 	/* Default word wrap to the full width, i.e. no word wrap */
! 	for (i = 0; i < col_count; i++)
! 		width_wrap[i] = max_width[i];
! 
! 	/*
! 	 * Optional optimized word wrap. Shrink columns with a high max/avg ratio.
! 	 * Slighly bias against wider columns. (Increases chance a narrow column
! 	 * will fit in its cell.)
! 	 */
! 	if (opt->format == PRINT_WRAPPED)
! 	{
! 		/* Get terminal width */
! 		if (opt->columns > 0)
! 			output_columns = opt->columns;
! 		else if (fout == stdout && isatty(fileno(stdout)))
! 		{
! #ifdef TIOCGWINSZ
! 			struct winsize screen_size;
! 
! 			if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
! 				output_columns = screen_size.ws_col;
! 			else
! #endif
! 			{
! 				const char *columns_env = getenv("COLUMNS");
! 
! 				if (columns_env)
! 					output_columns = atoi(columns_env);
! 			}
! 		}
! 
! 		/*
! 		 * If available columns is positive...
! 		 * and greater than the width of the unshrinkable column headers
! 		 */
! 		if (output_columns > 0 && output_columns >= total_header_width)
  		{
! 			/* While there is still excess width... */
! 			while (width_total > output_columns)
! 			{
! 				double		max_ratio = 0;
! 				int			worst_col = -1;
  
! 				/*
! 				 *	Find column that has the highest ratio of its maximum
! 				 *	width compared to its average width.  This tells us which
! 				 *	column will produce the fewest wrapped values if shortened.
! 				 *	width_wrap starts as equal to max_width.
! 				 */
! 				for (i = 0; i < col_count; i++)
! 				{
! 					if (width_average[i] && width_wrap[i] > width_header[i])
! 					{
! 						/* Penalize wide columns by +1% of their width (0.01) */
! 						double ratio = (double)width_wrap[i] / width_average[i] +
! 									max_width[i] * 0.01;
! 
! 						if (ratio > max_ratio)
! 						{
! 							max_ratio = ratio;
! 							worst_col = i;
! 						}
! 					}
! 				}
  
! 				/* Exit loop if we can't squeeze any more. */
! 				if (worst_col == -1)
! 					break;
! 
! 				/* Decrease width of target column by one. */
! 				width_wrap[worst_col]--;
! 				width_total--;
! 			}
  		}
  	}
  
+ 	/* time to output */
  	if (opt->start_table)
  	{
  		/* print title */
  		if (title && !opt_tuples_only)
  		{
! 			int			width, height;
  
! 			pg_wcssize((unsigned char *) title, strlen(title), encoding, &width, &height, NULL);
! 			if (width >= width_total)
! 				fprintf(fout, "%s\n", title);	/* Aligned */
  			else
! 				fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "", title);		/* Centered */
  		}
  
  		/* print headers */
  		if (!opt_tuples_only)
  		{
! 			int			more_col_wrapping;
! 			int			curr_nl_line;
  
  			if (opt_border == 2)
! 				_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  			for (i = 0; i < col_count; i++)
! 				pg_wcsformat((unsigned char *) headers[i], strlen(headers[i]),
! 							 encoding, col_lineptrs[i], max_nl_lines[i]);
  
! 			more_col_wrapping = col_count;
! 			curr_nl_line = 0;
! 			memset(header_done, false, col_count * sizeof(bool));
! 			while (more_col_wrapping)
  			{
  				if (opt_border == 2)
! 					fprintf(fout, "|%c", curr_nl_line ? '+' : ' ');
  				else if (opt_border == 1)
! 					fputc(curr_nl_line ? '+' : ' ', fout);
  
  				for (i = 0; i < col_count; i++)
  				{
  					unsigned int nbspace;
  
! 					struct lineptr *this_line = col_lineptrs[i] + curr_nl_line;
  
! 					if (!header_done[i])
  					{
! 						nbspace = width_wrap[i] - this_line->width;
  
  						/* centered */
  						fprintf(fout, "%-*s%s%-*s",
  								nbspace / 2, "", this_line->ptr, (nbspace + 1) / 2, "");
  
! 						if (!(this_line + 1)->ptr)
  						{
! 							more_col_wrapping--;
! 							header_done[i] = 1;
  						}
  					}
  					else
! 						fprintf(fout, "%*s", width_wrap[i], "");
  					if (i < col_count - 1)
  					{
  						if (opt_border == 0)
! 							fputc(curr_nl_line ? '+' : ' ', fout);
  						else
! 							fprintf(fout, " |%c", curr_nl_line ? '+' : ' ');
  					}
  				}
! 				curr_nl_line++;
  
  				if (opt_border == 2)
  					fputs(" |", fout);
  				else if (opt_border == 1)
! 					fputc(' ', fout);
  				fputc('\n', fout);
  			}
  
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  		}
  	}
  
! 	/* print cells, one loop per row */
  	for (i = 0, ptr = cells; *ptr; i += col_count, ptr += col_count)
  	{
! 		bool		more_lines;
  
  		if (cancel_pressed)
  			break;
  
+ 		/*
+ 		 * Format each cell.  Format again, it is a numeric formatting locale
+ 		 * (e.g. 123,456 vs. 123456)
+ 		 */
  		for (j = 0; j < col_count; j++)
! 		{
! 			pg_wcsformat((unsigned char *) ptr[j], strlen(ptr[j]), encoding, col_lineptrs[j], max_nl_lines[j]);
! 			curr_nl_line[j] = 0;
  
! 			if (opt_numeric_locale && opt_align[j % col_count] == 'r')
! 			{
! 				char	   *my_cell;
! 
! 				my_cell = format_numeric_locale((char *) col_lineptrs[j]->ptr);
! 				strcpy((char *) col_lineptrs[j]->ptr, my_cell); /* Buffer IS large
! 																 * enough... now */
! 				free(my_cell);
! 			}
! 		}
! 
! 		memset(bytes_output, 0, col_count * sizeof(int));
! 
! 		/*
! 		 *	Each time through this loop, one display line is output.
! 		 *	It can either be a full value or a partial value if embedded
! 		 *	newlines exist or if 'format=wrapping' mode is enabled.
! 		 */
! 		do
  		{
! 			more_lines = false;
! 
! 			/* left border */
  			if (opt_border == 2)
  				fputs("| ", fout);
  			else if (opt_border == 1)
  				fputc(' ', fout);
  
+ 			/* for each column */
  			for (j = 0; j < col_count; j++)
  			{
! 				/* We have a valid array element, so index it */
! 				struct lineptr *this_line = &col_lineptrs[j][curr_nl_line[j]];
! 				int		bytes_to_output,  chars_to_output = width_wrap[j];
! 
! 				/* Past newline lines so pad for other columns */
! 				if (!this_line->ptr)
! 					fprintf(fout, "%*s", width_wrap[j], "");
  				else
  				{
! 					/* Get strlen() of the width_wrap character */
! 					bytes_to_output = strlen_max_width(this_line->ptr +
! 									bytes_output[j], &chars_to_output, encoding);
! 
! 					/*
! 					 *	If we exceeded width_wrap, it means the display width
! 					 *	of a single character was wider than our target width.
! 					 *	In that case, we have to pretend we are only printing
! 					 *	the target display width and make the best of it.
! 					 */
! 					if (chars_to_output > width_wrap[j])
! 						chars_to_output = width_wrap[j];
! 
! 					if (opt_align[j] == 'r')		/* Right aligned cell */
  					{
! 						/* spaces first */
! 						fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
! 						fprintf(fout, "%.*s", bytes_to_output,
! 								this_line->ptr + bytes_output[j]);
! 					}
! 					else	/* Left aligned cell */
! 					{
! 						/* spaces second */
! 						fprintf(fout, "%.*s", bytes_to_output,
! 								this_line->ptr + bytes_output[j]);
! 						fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
  					}
+ 
+ 					bytes_output[j] += bytes_to_output;
+ 
+ 					/* Do we have more text to wrap? */
+ 					if (*(this_line->ptr + bytes_output[j]) != 0)
+ 						more_lines = true;
  					else
  					{
! 						/* Advance to next newline line */
! 						curr_nl_line[j]++;
! 						if (col_lineptrs[j][curr_nl_line[j]].ptr != NULL)
! 							more_lines = true;
! 						bytes_output[j] = 0;
  					}
  				}
  
! 				/* print a divider, middle columns only */
  				if ((j + 1) % col_count)
  				{
  					if (opt_border == 0)
  						fputc(' ', fout);
! 					/* Next value is beyond past newlines? */
! 					else if (col_lineptrs[j+1][curr_nl_line[j+1]].ptr == NULL)
! 						fputs("   ", fout);
! 					/* In wrapping of value? */
! 					else if (bytes_output[j+1] != 0)
! 						fputs(" ; ", fout);
! 					/* After first newline value */
! 					else if (curr_nl_line[j+1] != 0)
! 						fputs(" : ", fout);
  					else
! 					/* Ordinary line */
! 						fputs(" | ", fout);
  				}
+ 
  			}
+ 
+ 			/* end of row border */
  			if (opt_border == 2)
  				fputs(" |", fout);
  			fputc('\n', fout);
! 
! 		} while (more_lines);
  	}
  
  	if (opt->stop_table)
  	{
  		if (opt_border == 2 && !cancel_pressed)
! 			_print_horizontal_line(col_count, width_wrap, opt_border, fout);
  
  		/* print footers */
  		if (footers && !opt_tuples_only && !cancel_pressed)
***************
*** 722,733 ****
  	}
  
  	/* 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);
--- 867,882 ----
  	}
  
  	/* clean up */
! 	free(width_header);
! 	free(width_average);
! 	free(max_width);
! 	free(width_wrap);
! 	free(max_nl_lines);
! 	free(curr_nl_line);
  	free(col_lineptrs);
! 	free(max_bytes);
! 	free(header_done);
! 	free(bytes_output);
  	for (i = 0; i < col_count; i++)
  		free(format_buf[i]);
  	free(format_buf);
***************
*** 754,760 ****
  				dheight = 1,
  				hformatsize = 0,
  				dformatsize = 0;
- 	int			tmp = 0;
  	char	   *divider;
  	unsigned int cell_count = 0;
  	struct lineptr *hlineptr,
--- 903,908 ----
***************
*** 779,790 ****
  	/* 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)
--- 927,939 ----
  	/* Find the maximum dimensions for the headers */
  	for (i = 0; i < col_count; i++)
  	{
! 		int			width,
! 					height,
  					fs;
  
! 		pg_wcssize((unsigned char *) headers[i], strlen(headers[i]), encoding, &width, &height, &fs);
! 		if (width > hwidth)
! 			hwidth = width;
  		if (height > hheight)
  			hheight = height;
  		if (fs > hformatsize)
***************
*** 799,805 ****
  	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)
--- 948,955 ----
  	for (i = 0, ptr = cells; *ptr; ptr++, i++)
  	{
  		int			numeric_locale_len;
! 		int			width,
! 					height,
  					fs;
  
  		if (opt_align[i % col_count] == 'r' && opt_numeric_locale)
***************
*** 807,816 ****
  		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)
--- 957,966 ----
  		else
  			numeric_locale_len = 0;
  
! 		pg_wcssize((unsigned char *) *ptr, strlen(*ptr), encoding, &width, &height, &fs);
! 		width += numeric_locale_len;
! 		if (width > dwidth)
! 			dwidth = width;
  		if (height > dheight)
  			dheight = height;
  		if (fs > dformatsize)
***************
*** 821,828 ****
  	 * 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);
--- 971,978 ----
  	 * We now have all the information we need to setup the formatting
  	 * structures
  	 */
! 	dlineptr = pg_local_malloc((sizeof(*dlineptr) + 1) * dheight);
! 	hlineptr = pg_local_malloc((sizeof(*hlineptr) + 1) * hheight);
  
  	dlineptr->ptr = pg_local_malloc(dformatsize);
  	hlineptr->ptr = pg_local_malloc(hformatsize);
***************
*** 910,916 ****
  				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
--- 1060,1066 ----
  				fprintf(fout, "%-s%*s", hlineptr[line_count].ptr,
  						hwidth - hlineptr[line_count].width, "");
  
! 				if (!hlineptr[line_count + 1].ptr)
  					hcomplete = 1;
  			}
  			else
***************
*** 943,949 ****
  								dwidth - dlineptr[line_count].width, "");
  				}
  
! 				if (line_count == dheight - 1 || !dlineptr[line_count + 1].ptr)
  					dcomplete = 1;
  			}
  			else
--- 1093,1099 ----
  								dwidth - dlineptr[line_count].width, "");
  				}
  
! 				if (!dlineptr[line_count + 1].ptr)
  					dcomplete = 1;
  			}
  			else
***************
*** 1879,1884 ****
--- 2029,2035 ----
  									 opt, output);
  			break;
  		case PRINT_ALIGNED:
+ 		case PRINT_WRAPPED:
  			if (opt->expanded)
  				print_aligned_vertical(title, headers, cells, footers, align,
  									   opt, output);
***************
*** 2066,2068 ****
--- 2217,2254 ----
  	else
  		thousands_sep = ".";
  }
+ 
+ /*
+  *	Returns the byte length to the end of the specified character
+  *  and number of display characters processed (useful if the string
+  *	is shorter then dpylen).
+  */
+ static int
+ strlen_max_width(unsigned char *str, int *target_width, int encoding)
+ {
+ 	unsigned char *start = str;
+ 	int curr_width = 0;
+ 
+ 	while (*str && curr_width < *target_width)
+ 	{
+ 		int char_width = PQdsplen((char *) str, encoding);
+ 
+ 		/*
+ 		 *	If the display width of the new character causes
+ 		 *	the string to exceed its target width, skip it
+ 		 *	and return.  However, if this is the first character
+ 		 *	of the string (*width == 0), we have to accept it.
+ 		 */
+ 		if (*target_width - curr_width < char_width && curr_width != 0)
+ 			break;
+ 			
+ 		str += PQmblen((char *)str, encoding);
+ 
+ 		curr_width += char_width;
+ 	}
+ 
+ 	*target_width = curr_width;
+ 	
+ 	/* last byte */
+ 	return str - start;
+ }
Index: src/bin/psql/print.h
===================================================================
RCS file: /cvsroot/pgsql/src/bin/psql/print.h,v
retrieving revision 1.35
diff -c -c -r1.35 print.h
*** src/bin/psql/print.h	1 Jan 2008 19:45:56 -0000	1.35
--- src/bin/psql/print.h	29 Apr 2008 01:24:48 -0000
***************
*** 21,26 ****
--- 21,27 ----
  	PRINT_NOTHING = 0,			/* to make sure someone initializes this */
  	PRINT_UNALIGNED,
  	PRINT_ALIGNED,
+ 	PRINT_WRAPPED,
  	PRINT_HTML,
  	PRINT_LATEX,
  	PRINT_TROFF_MS
***************
*** 47,52 ****
--- 48,54 ----
  								 * decimal marker */
  	char	   *tableAttr;		/* attributes for HTML <table ...> */
  	int			encoding;		/* character encoding */
+ 	int			columns;		/* target width for wrapped format */
  } printTableOpt;