print.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * Query-result printing support for frontend code
 *
 * This file used to be part of psql, but now it's separated out to allow
 * other frontend programs to use it.  Because the printing code needs
 * access to the cancel_pressed flag as well as SIGPIPE trapping and
 * pager open/close functions, all that stuff came with it.
 *
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/fe_utils/print.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres_fe.h"
 
#include <limits.h>
#include <math.h>
#include <unistd.h>
 
#ifndef WIN32
#include <sys/ioctl.h>          /* for ioctl() */
#endif
 
#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif
 
#include "catalog/pg_type_d.h"
#include "fe_utils/mbprint.h"
#include "fe_utils/print.h"
 
/* Presently, count_table_lines() is only used within #ifdef TIOCGWINSZ */
#ifdef TIOCGWINSZ
#define NEED_COUNT_TABLE_LINES
#endif
 
/*
 * If the calling program doesn't have any mechanism for setting
 * cancel_pressed, it 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 sig_atomic_t cancel_pressed = false;
 
static bool always_ignore_sigpipe = false;
 
/* info for locale-aware numeric formatting; set up by setDecimalLocale() */
static char *decimal_point;
static int  groupdigits;
static char *thousands_sep;
 
static char default_footer[100];
static printTableFooter default_footer_cell = {default_footer, NULL};
 
/* Line style control structures */
const printTextFormat pg_asciiformat =
{
    "ascii",
    {
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"", "|", "|", "|"}
    },
    "|",
    "|",
    "|",
    " ",
    "+",
    " ",
    "+",
    ".",
    ".",
    true
};
 
const printTextFormat pg_asciiformat_old =
{
    "old-ascii",
    {
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"", "|", "|", "|"}
    },
    ":",
    ";",
    " ",
    "+",
    " ",
    " ",
    " ",
    " ",
    " ",
    false
};
 
/* Default unicode linestyle format */
printTextFormat pg_utf8format;
 
typedef struct unicodeStyleRowFormat
{
    const char *horizontal;
    const char *vertical_and_right[2];
    const char *vertical_and_left[2];
} unicodeStyleRowFormat;
 
typedef struct unicodeStyleColumnFormat
{
    const char *vertical;
    const char *vertical_and_horizontal[2];
    const char *up_and_horizontal[2];
    const char *down_and_horizontal[2];
} unicodeStyleColumnFormat;
 
typedef struct unicodeStyleBorderFormat
{
    const char *up_and_right;
    const char *vertical;
    const char *down_and_right;
    const char *horizontal;
    const char *down_and_left;
    const char *left_and_right;
} unicodeStyleBorderFormat;
 
typedef struct unicodeStyleFormat
{
    unicodeStyleRowFormat row_style[2];
    unicodeStyleColumnFormat column_style[2];
    unicodeStyleBorderFormat border_style[2];
    const char *header_nl_left;
    const char *header_nl_right;
    const char *nl_left;
    const char *nl_right;
    const char *wrap_left;
    const char *wrap_right;
    bool        wrap_right_border;
} unicodeStyleFormat;
 
static const unicodeStyleFormat unicode_style = {
    {
        {
            /* U+2500 Box Drawings Light Horizontal */
            "\342\224\200",
 
            /*--
             * U+251C Box Drawings Light Vertical and Right,
             * U+255F Box Drawings Vertical Double and Right Single
             *--
             */
            {"\342\224\234", "\342\225\237"},
 
            /*--
             * U+2524 Box Drawings Light Vertical and Left,
             * U+2562 Box Drawings Vertical Double and Left Single
             *--
             */
            {"\342\224\244", "\342\225\242"},
        },
        {
            /* U+2550 Box Drawings Double Horizontal */
            "\342\225\220",
 
            /*--
             * U+255E Box Drawings Vertical Single and Right Double,
             * U+2560 Box Drawings Double Vertical and Right
             *--
             */
            {"\342\225\236", "\342\225\240"},
 
            /*--
             * U+2561 Box Drawings Vertical Single and Left Double,
             * U+2563 Box Drawings Double Vertical and Left
             *--
             */
            {"\342\225\241", "\342\225\243"},
        },
    },
    {
        {
            /* U+2502 Box Drawings Light Vertical */
            "\342\224\202",
 
            /*--
             * U+253C Box Drawings Light Vertical and Horizontal,
             * U+256A Box Drawings Vertical Single and Horizontal Double
             *--
             */
            {"\342\224\274", "\342\225\252"},
 
            /*--
             * U+2534 Box Drawings Light Up and Horizontal,
             * U+2567 Box Drawings Up Single and Horizontal Double
             *--
             */
            {"\342\224\264", "\342\225\247"},
 
            /*--
             * U+252C Box Drawings Light Down and Horizontal,
             * U+2564 Box Drawings Down Single and Horizontal Double
             *--
             */
            {"\342\224\254", "\342\225\244"},
        },
        {
            /* U+2551 Box Drawings Double Vertical */
            "\342\225\221",
 
            /*--
             * U+256B Box Drawings Vertical Double and Horizontal Single,
             * U+256C Box Drawings Double Vertical and Horizontal
             *--
             */
            {"\342\225\253", "\342\225\254"},
 
            /*--
             * U+2568 Box Drawings Up Double and Horizontal Single,
             * U+2569 Box Drawings Double Up and Horizontal
             *--
             */
            {"\342\225\250", "\342\225\251"},
 
            /*--
             * U+2565 Box Drawings Down Double and Horizontal Single,
             * U+2566 Box Drawings Double Down and Horizontal
             *--
             */
            {"\342\225\245", "\342\225\246"},
        },
    },
    {
        /*--
         * U+2514 Box Drawings Light Up and Right,
         * U+2502 Box Drawings Light Vertical,
         * U+250C Box Drawings Light Down and Right,
         * U+2500 Box Drawings Light Horizontal,
         * U+2510 Box Drawings Light Down and Left,
         * U+2518 Box Drawings Light Up and Left
         *--
         */
        {"\342\224\224", "\342\224\202", "\342\224\214", "\342\224\200", "\342\224\220", "\342\224\230"},
 
        /*--
         * U+255A Box Drawings Double Up and Right,
         * U+2551 Box Drawings Double Vertical,
         * U+2554 Box Drawings Double Down and Right,
         * U+2550 Box Drawings Double Horizontal,
         * U+2557 Box Drawings Double Down and Left,
         * U+255D Box Drawings Double Up and Left
         *--
         */
        {"\342\225\232", "\342\225\221", "\342\225\224", "\342\225\220", "\342\225\227", "\342\225\235"},
    },
    " ",
    /* U+21B5 Downwards Arrow with Corner Leftwards */
    "\342\206\265",
    " ",
    /* U+21B5 Downwards Arrow with Corner Leftwards */
    "\342\206\265",
    /* U+2026 Horizontal Ellipsis */
    "\342\200\246",
    "\342\200\246",
    true
};
 
 
/* Local functions */
static int  strlen_max_width(unsigned char *str, int *target_width, int encoding);
static FILE *PageOutputInternal(int lines, const printTableOpt *topt,
                                const printTableContent *cont,
                                const unsigned int *width_wrap,
                                bool vertical);
static void IsPagerNeeded(const printTableContent *cont,
                          const unsigned int *width_wrap,
                          bool vertical,
                          FILE **fout, bool *is_pager);
#ifdef NEED_COUNT_TABLE_LINES
static int  count_table_lines(const printTableContent *cont,
                              const unsigned int *width_wrap,
                              bool vertical,
                              int threshold);
#endif
static void print_aligned_vertical(const printTableContent *cont,
                                   FILE *fout, bool is_pager);
 
 
/* Count number of digits in integral part of number */
static int
integer_digits(const char *my_str)
{
    /* ignoring any sign ... */
    if (my_str[0] == '-' || my_str[0] == '+')
        my_str++;
    /* ... count initial integral digits */
    return strspn(my_str, "0123456789");
}
 
/* Compute 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;
 
    /* Account for added thousands_sep instances */
    if (int_len > groupdigits)
        len += ((int_len - 1) / groupdigits) * strlen(thousands_sep);
 
    /* Account for possible additional length of decimal_point */
    if (strchr(my_str, '.') != NULL)
        len += strlen(decimal_point) - 1;
 
    return len;
}
 
/*
 * Format a numeric value per current LC_NUMERIC locale setting
 *
 * Returns the appropriately formatted string in a new allocated block,
 * caller must free.
 *
 * setDecimalLocale() must have been called earlier.
 */
static char *
format_numeric_locale(const char *my_str)
{
    char       *new_str;
    int         new_len,
                int_len,
                leading_digits,
                i,
                new_str_pos;
 
    /*
     * If the string doesn't look like a number, return it unchanged.  This
     * check is essential to avoid mangling already-localized "money" values.
     */
    if (strspn(my_str, "0123456789+-.eE") != strlen(my_str))
        return pg_strdup(my_str);
 
    new_len = strlen(my_str) + additional_numeric_locale_len(my_str);
    new_str = pg_malloc_array(char, (new_len + 1));
    new_str_pos = 0;
    int_len = integer_digits(my_str);
 
    /* number of digits in first thousands group */
    leading_digits = int_len % groupdigits;
    if (leading_digits == 0)
        leading_digits = groupdigits;
 
    /* process sign */
    if (my_str[0] == '-' || my_str[0] == '+')
    {
        new_str[new_str_pos++] = my_str[0];
        my_str++;
    }
 
    /* process integer part of number */
    for (i = 0; i < int_len; i++)
    {
        /* Time to insert separator? */
        if (i > 0 && --leading_digits == 0)
        {
            strcpy(&new_str[new_str_pos], thousands_sep);
            new_str_pos += strlen(thousands_sep);
            leading_digits = groupdigits;
        }
        new_str[new_str_pos++] = my_str[i];
    }
 
    /* handle decimal point if any */
    if (my_str[i] == '.')
    {
        strcpy(&new_str[new_str_pos], decimal_point);
        new_str_pos += strlen(decimal_point);
        i++;
    }
 
    /* copy the rest (fractional digits and/or exponent, and \0 terminator) */
    strcpy(&new_str[new_str_pos], &my_str[i]);
 
    /* assert we didn't underestimate new_len (an overestimate is OK) */
    Assert(strlen(new_str) <= new_len);
 
    return new_str;
}
 
 
static void
print_separator(struct separator sep, FILE *fout)
{
    if (sep.separator_zero)
        fputc('\000', fout);
    else if (sep.separator)
        fputs(sep.separator, fout);
}
 
 
/*
 * Return the list of explicitly-requested footers or, when applicable, the
 * default "(xx rows)" footer.  Always omit the default footer when given
 * non-default footers, "\pset footer off", or a specific instruction to that
 * effect from a calling backslash command.  Vertical formats number each row,
 * making the default footer redundant; they do not call this function.
 *
 * The return value may point to static storage; do not keep it across calls.
 */
static printTableFooter *
footers_with_default(const printTableContent *cont)
{
    if (cont->footers == NULL && cont->opt->default_footer)
    {
        unsigned long total_records;
 
        total_records = cont->opt->prior_records + cont->nrows;
        snprintf(default_footer, sizeof(default_footer),
                 ngettext("(%lu row)", "(%lu rows)", total_records),
                 total_records);
 
        return &default_footer_cell;
    }
    else
        return cont->footers;
}
 
 
/*************************/
/* Unaligned text        */
/*************************/
 
 
static void
print_unaligned_text(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned int i;
    const char *const *ptr;
    bool        need_recordsep = false;
 
    if (cancel_pressed)
        return;
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs(cont->title, fout);
            print_separator(cont->opt->recordSep, fout);
        }
 
        /* print headers */
        if (!opt_tuples_only)
        {
            for (ptr = cont->headers; *ptr; ptr++)
            {
                if (ptr != cont->headers)
                    print_separator(cont->opt->fieldSep, fout);
                fputs(*ptr, fout);
            }
            need_recordsep = true;
        }
    }
    else
        /* assume continuing printout */
        need_recordsep = true;
 
    /* print cells */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        if (need_recordsep)
        {
            print_separator(cont->opt->recordSep, fout);
            need_recordsep = false;
            if (cancel_pressed)
                break;
        }
        fputs(*ptr, fout);
 
        if ((i + 1) % cont->ncolumns)
            print_separator(cont->opt->fieldSep, fout);
        else
            need_recordsep = true;
    }
 
    /* print footers */
    if (cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        if (!opt_tuples_only && footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            for (f = footers; f; f = f->next)
            {
                if (need_recordsep)
                {
                    print_separator(cont->opt->recordSep, fout);
                    need_recordsep = false;
                }
                fputs(f->data, fout);
                need_recordsep = true;
            }
        }
 
        /*
         * The last record is terminated by a newline, independent of the set
         * record separator.  But when the record separator is a zero byte, we
         * use that (compatible with find -print0 and xargs).
         */
        if (need_recordsep)
        {
            if (cont->opt->recordSep.separator_zero)
                print_separator(cont->opt->recordSep, fout);
            else
                fputc('\n', fout);
        }
    }
}
 
 
static void
print_unaligned_vertical(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned int i;
    const char *const *ptr;
    bool        need_recordsep = false;
 
    if (cancel_pressed)
        return;
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs(cont->title, fout);
            need_recordsep = true;
        }
    }
    else
        /* assume continuing printout */
        need_recordsep = true;
 
    /* print records */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        if (need_recordsep)
        {
            /* record separator is 2 occurrences of recordsep in this mode */
            print_separator(cont->opt->recordSep, fout);
            print_separator(cont->opt->recordSep, fout);
            need_recordsep = false;
            if (cancel_pressed)
                break;
        }
 
        fputs(cont->headers[i % cont->ncolumns], fout);
        print_separator(cont->opt->fieldSep, fout);
        fputs(*ptr, fout);
 
        if ((i + 1) % cont->ncolumns)
            print_separator(cont->opt->recordSep, fout);
        else
            need_recordsep = true;
    }
 
    if (cont->opt->stop_table)
    {
        /* print footers */
        if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            print_separator(cont->opt->recordSep, fout);
            for (f = cont->footers; f; f = f->next)
            {
                print_separator(cont->opt->recordSep, fout);
                fputs(f->data, fout);
            }
        }
 
        /* see above in print_unaligned_text() */
        if (need_recordsep)
        {
            if (cont->opt->recordSep.separator_zero)
                print_separator(cont->opt->recordSep, fout);
            else
                fputc('\n', fout);
        }
    }
}
 
 
/********************/
/* Aligned text     */
/********************/
 
 
/* draw "line" */
static void
_print_horizontal_line(const unsigned int ncolumns, const unsigned int *widths,
                       unsigned short border, printTextRule pos,
                       const printTextFormat *format,
                       FILE *fout)
{
    const printTextLineFormat *lformat = &format->lrule[pos];
    unsigned int i,
                j;
 
    if (border == 1)
        fputs(lformat->hrule, fout);
    else if (border == 2)
        fprintf(fout, "%s%s", lformat->leftvrule, lformat->hrule);
 
    for (i = 0; i < ncolumns; i++)
    {
        for (j = 0; j < widths[i]; j++)
            fputs(lformat->hrule, fout);
 
        if (i < ncolumns - 1)
        {
            if (border == 0)
                fputc(' ', fout);
            else
                fprintf(fout, "%s%s%s", lformat->hrule,
                        lformat->midvrule, lformat->hrule);
        }
    }
 
    if (border == 2)
        fprintf(fout, "%s%s", lformat->hrule, lformat->rightvrule);
    else if (border == 1)
        fputs(lformat->hrule, fout);
 
    fputc('\n', fout);
}
 
 
/*
 *  Print pretty boxes around cells.
 */
static void
print_aligned_text(const printTableContent *cont, FILE *fout, bool is_pager)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    int         encoding = cont->opt->encoding;
    unsigned short opt_border = cont->opt->border;
    const printTextFormat *format = get_line_style(cont->opt);
    const printTextLineFormat *dformat = &format->lrule[PRINT_RULE_DATA];
 
    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 */
    printTextLineWrap *wrap;    /* Wrap status for each column */
    int         output_columns = 0; /* Width of interactive console */
    bool        is_local_pager = false;
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 2)
        opt_border = 2;
 
    if (cont->ncolumns > 0)
    {
        col_count = cont->ncolumns;
        width_header = pg_malloc0_array(unsigned int, col_count);
        width_average = pg_malloc0_array(unsigned int, col_count);
        max_width = pg_malloc0_array(unsigned int, col_count);
        width_wrap = pg_malloc0_array(unsigned int, col_count);
        max_nl_lines = pg_malloc0_array(unsigned int, col_count);
        curr_nl_line = pg_malloc0_array(unsigned int, col_count);
        col_lineptrs = pg_malloc0_array(struct lineptr *, col_count);
        max_bytes = pg_malloc0_array(unsigned int, col_count);
        format_buf = pg_malloc0_array(unsigned char *, col_count);
        header_done = pg_malloc0_array(bool, col_count);
        bytes_output = pg_malloc0_array(int, col_count);
        wrap = pg_malloc0_array(printTextLineWrap, col_count);
    }
    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;
        wrap = 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((const unsigned char *) cont->headers[i], strlen(cont->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 = cont->cells; *ptr; ptr++, cell_count++)
    {
        int         width,
                    nl_lines,
                    bytes_required;
 
        pg_wcssize((const unsigned char *) *ptr, strlen(*ptr), 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_average[i] += width;
 
        /* i is the current column number: increment with wrap */
        if (++i >= col_count)
            i = 0;
    }
 
    /* 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] /= rows;
    }
 
    /* adjust the total display width based on border style */
    if (opt_border == 0)
        width_total = col_count;
    else if (opt_border == 1)
        width_total = col_count * 3 - ((col_count > 0) ? 1 : 0);
    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_malloc0_array(struct lineptr,
                                           (max_nl_lines[i] + 1));
 
        format_buf[i] = pg_malloc_array(unsigned char, (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];
 
    /*
     * Choose target output width: \pset columns, or $COLUMNS, or ioctl
     */
    if (cont->opt->columns > 0)
        output_columns = cont->opt->columns;
    else if ((fout == stdout && isatty(fileno(stdout))) || is_pager)
    {
        if (cont->opt->env_columns > 0)
            output_columns = cont->opt->env_columns;
#ifdef TIOCGWINSZ
        else
        {
            struct winsize screen_size;
 
            if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
                output_columns = screen_size.ws_col;
        }
#endif
    }
 
    if (cont->opt->format == PRINT_WRAPPED)
    {
        /*
         * Optional optimized word wrap. Shrink columns with a high max/avg
         * ratio.  Slightly bias against wider columns. (Increases chance a
         * narrow column will fit in its cell.)  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 */
                        double      ratio;
 
                        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--;
            }
        }
    }
 
    /*
     * If in expanded auto mode, we have now calculated the expected width, so
     * we can now escape to vertical mode if necessary.  If the output has
     * only one column, the expanded format would be wider than the regular
     * format, so don't use it in that case.
     */
    if (cont->opt->expanded == 2 && output_columns > 0 && cont->ncolumns > 1 &&
        (output_columns < total_header_width || output_columns < width_total))
    {
        print_aligned_vertical(cont, fout, is_pager);
        goto cleanup;
    }
 
    /* If we wrapped beyond the display width, use the pager */
    if (!is_pager && fout == stdout && output_columns > 0 &&
        (output_columns < total_header_width || output_columns < width_total))
    {
        fout = PageOutput(INT_MAX, cont->opt);  /* force pager */
        is_pager = is_local_pager = true;
    }
 
    /* Check if there are enough lines to require the pager */
    if (!is_pager)
    {
        IsPagerNeeded(cont, width_wrap, false, &fout, &is_pager);
        is_local_pager = is_pager;
    }
 
    /* time to output */
    if (cont->opt->start_table)
    {
        /* print title */
        if (cont->title && !opt_tuples_only)
        {
            int         width,
                        height;
 
            pg_wcssize((const unsigned char *) cont->title, strlen(cont->title),
                       encoding, &width, &height, NULL);
            if (width >= width_total)
                /* Aligned */
                fprintf(fout, "%s\n", cont->title);
            else
                /* Centered */
                fprintf(fout, "%-*s%s\n", (width_total - width) / 2, "",
                        cont->title);
        }
 
        /* 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,
                                       PRINT_RULE_TOP, format, fout);
 
            for (i = 0; i < col_count; i++)
                pg_wcsformat((const unsigned char *) cont->headers[i],
                             strlen(cont->headers[i]), encoding,
                             col_lineptrs[i], max_nl_lines[i]);
 
            more_col_wrapping = col_count;
            curr_nl_line = 0;
            if (col_count > 0)
                memset(header_done, false, col_count * sizeof(bool));
            while (more_col_wrapping)
            {
                if (opt_border == 2)
                    fputs(dformat->leftvrule, fout);
 
                for (i = 0; i < cont->ncolumns; i++)
                {
                    struct lineptr *this_line = col_lineptrs[i] + curr_nl_line;
                    unsigned int nbspace;
 
                    if (opt_border != 0 ||
                        (!format->wrap_right_border && i > 0))
                        fputs(curr_nl_line ? format->header_nl_left : " ",
                              fout);
 
                    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 (opt_border != 0 || format->wrap_right_border)
                        fputs(!header_done[i] ? format->header_nl_right : " ",
                              fout);
 
                    if (opt_border != 0 && col_count > 0 && i < col_count - 1)
                        fputs(dformat->midvrule, fout);
                }
                curr_nl_line++;
 
                if (opt_border == 2)
                    fputs(dformat->rightvrule, fout);
                fputc('\n', fout);
            }
 
            _print_horizontal_line(col_count, width_wrap, opt_border,
                                   PRINT_RULE_MIDDLE, format, fout);
        }
    }
 
    /* print cells, one loop per row */
    for (i = 0, ptr = cont->cells; *ptr; i += col_count, ptr += col_count)
    {
        bool        more_lines;
 
        if (cancel_pressed)
            break;
 
        /*
         * Format each cell.
         */
        for (j = 0; j < col_count; j++)
        {
            pg_wcsformat((const unsigned char *) ptr[j], strlen(ptr[j]), encoding,
                         col_lineptrs[j], max_nl_lines[j]);
            curr_nl_line[j] = 0;
        }
 
        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(dformat->leftvrule, 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;
                int         chars_to_output = width_wrap[j];
                bool        finalspaces = (opt_border == 2 ||
                                           (col_count > 0 && j < col_count - 1));
 
                /* Print left-hand wrap or newline mark */
                if (opt_border != 0)
                {
                    if (wrap[j] == PRINT_LINE_WRAP_WRAP)
                        fputs(format->wrap_left, fout);
                    else if (wrap[j] == PRINT_LINE_WRAP_NEWLINE)
                        fputs(format->nl_left, fout);
                    else
                        fputc(' ', fout);
                }
 
                if (!this_line->ptr)
                {
                    /* Past newline lines so just pad for other columns */
                    if (finalspaces)
                        fprintf(fout, "%*s", chars_to_output, "");
                }
                else
                {
                    /* Get strlen() of the characters up to width_wrap */
                    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 (cont->aligns[j] == 'r') /* Right aligned cell */
                    {
                        /* spaces first */
                        fprintf(fout, "%*s", width_wrap[j] - chars_to_output, "");
                        fwrite((char *) (this_line->ptr + bytes_output[j]),
                               1, bytes_to_output, fout);
                    }
                    else        /* Left aligned cell */
                    {
                        /* spaces second */
                        fwrite((char *) (this_line->ptr + bytes_output[j]),
                               1, bytes_to_output, fout);
                    }
 
                    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;
                    }
                }
 
                /* Determine next line's wrap status for this column */
                wrap[j] = PRINT_LINE_WRAP_NONE;
                if (col_lineptrs[j][curr_nl_line[j]].ptr != NULL)
                {
                    if (bytes_output[j] != 0)
                        wrap[j] = PRINT_LINE_WRAP_WRAP;
                    else if (curr_nl_line[j] != 0)
                        wrap[j] = PRINT_LINE_WRAP_NEWLINE;
                }
 
                /*
                 * If left-aligned, pad out remaining space if needed (not
                 * last column, and/or wrap marks required).
                 */
                if (cont->aligns[j] != 'r') /* Left aligned cell */
                {
                    if (finalspaces ||
                        wrap[j] == PRINT_LINE_WRAP_WRAP ||
                        wrap[j] == PRINT_LINE_WRAP_NEWLINE)
                        fprintf(fout, "%*s",
                                width_wrap[j] - chars_to_output, "");
                }
 
                /* Print right-hand wrap or newline mark */
                if (wrap[j] == PRINT_LINE_WRAP_WRAP)
                    fputs(format->wrap_right, fout);
                else if (wrap[j] == PRINT_LINE_WRAP_NEWLINE)
                    fputs(format->nl_right, fout);
                else if (opt_border == 2 || (col_count > 0 && j < col_count - 1))
                    fputc(' ', fout);
 
                /* Print column divider, if not the last column */
                if (opt_border != 0 && (col_count > 0 && j < col_count - 1))
                {
                    if (wrap[j + 1] == PRINT_LINE_WRAP_WRAP)
                        fputs(format->midvrule_wrap, fout);
                    else if (wrap[j + 1] == PRINT_LINE_WRAP_NEWLINE)
                        fputs(format->midvrule_nl, fout);
                    else if (col_lineptrs[j + 1][curr_nl_line[j + 1]].ptr == NULL)
                        fputs(format->midvrule_blank, fout);
                    else
                        fputs(dformat->midvrule, fout);
                }
            }
 
            /* end-of-row border */
            if (opt_border == 2)
                fputs(dformat->rightvrule, fout);
            fputc('\n', fout);
        } while (more_lines);
    }
 
    if (cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        if (opt_border == 2 && !cancel_pressed)
            _print_horizontal_line(col_count, width_wrap, opt_border,
                                   PRINT_RULE_BOTTOM, format, fout);
 
        /* print footers */
        if (footers && !opt_tuples_only && !cancel_pressed)
        {
            printTableFooter *f;
 
            for (f = footers; f; f = f->next)
                fprintf(fout, "%s\n", f->data);
        }
 
        fputc('\n', fout);
    }
 
cleanup:
    /* clean up */
    for (i = 0; i < col_count; i++)
    {
        free(col_lineptrs[i]);
        free(format_buf[i]);
    }
    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(format_buf);
    free(header_done);
    free(bytes_output);
    free(wrap);
 
    if (is_local_pager)
        ClosePager(fout);
}
 
 
static void
print_aligned_vertical_line(const printTableOpt *topt,
                            unsigned long record,
                            unsigned int hwidth,
                            unsigned int dwidth,
                            int output_columns,
                            printTextRule pos,
                            FILE *fout)
{
    const printTextLineFormat *lformat = &get_line_style(topt)->lrule[pos];
    const unsigned short opt_border = topt->border;
    unsigned int i;
    int         reclen = 0;
 
    if (opt_border == 2)
        fprintf(fout, "%s%s", lformat->leftvrule, lformat->hrule);
    else if (opt_border == 1)
        fputs(lformat->hrule, fout);
 
    if (record)
    {
        if (opt_border == 0)
            reclen = fprintf(fout, "* Record %lu", record);
        else
            reclen = fprintf(fout, "[ RECORD %lu ]", record);
    }
    if (opt_border != 2)
        reclen++;
    if (reclen < 0)
        reclen = 0;
    for (i = reclen; i < hwidth; i++)
        fputs(opt_border > 0 ? lformat->hrule : " ", fout);
    reclen -= hwidth;
 
    if (opt_border > 0)
    {
        if (reclen-- <= 0)
            fputs(lformat->hrule, fout);
        if (reclen-- <= 0)
        {
            if (topt->expanded_header_width_type == PRINT_XHEADER_COLUMN)
            {
                fputs(lformat->rightvrule, fout);
            }
            else
            {
                fputs(lformat->midvrule, fout);
            }
        }
        if (reclen-- <= 0
            && topt->expanded_header_width_type != PRINT_XHEADER_COLUMN)
            fputs(lformat->hrule, fout);
    }
    else
    {
        if (reclen-- <= 0)
            fputc(' ', fout);
    }
 
    if (topt->expanded_header_width_type != PRINT_XHEADER_COLUMN)
    {
        if (topt->expanded_header_width_type == PRINT_XHEADER_PAGE
            || topt->expanded_header_width_type == PRINT_XHEADER_EXACT_WIDTH)
        {
            if (topt->expanded_header_width_type == PRINT_XHEADER_EXACT_WIDTH)
            {
                output_columns = topt->expanded_header_exact_width;
            }
            if (output_columns > 0)
            {
                if (opt_border == 0)
                    dwidth = Min(dwidth, Max(0, (int) (output_columns - hwidth)));
                if (opt_border == 1)
                    dwidth = Min(dwidth, Max(0, (int) (output_columns - hwidth - 3)));
 
                /*
                 * Handling the xheader width for border=2 doesn't make much
                 * sense because this format has an additional right border,
                 * but keep this for consistency.
                 */
                if (opt_border == 2)
                    dwidth = Min(dwidth, Max(0, (int) (output_columns - hwidth - 7)));
            }
        }
 
        if (reclen < 0)
            reclen = 0;
        if (dwidth < reclen)
            dwidth = reclen;
 
        for (i = reclen; i < dwidth; i++)
            fputs(opt_border > 0 ? lformat->hrule : " ", fout);
        if (opt_border == 2)
            fprintf(fout, "%s%s", lformat->hrule, lformat->rightvrule);
    }
 
    fputc('\n', fout);
}
 
static void
print_aligned_vertical(const printTableContent *cont,
                       FILE *fout, bool is_pager)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    const printTextFormat *format = get_line_style(cont->opt);
    const printTextLineFormat *dformat = &format->lrule[PRINT_RULE_DATA];
    int         encoding = cont->opt->encoding;
    unsigned long record = cont->opt->prior_records + 1;
    const char *const *ptr;
    unsigned int i,
                hwidth = 0,
                dwidth = 0,
                hheight = 1,
                dheight = 1,
                hformatsize = 0,
                dformatsize = 0;
    struct lineptr *hlineptr,
               *dlineptr;
    bool        is_local_pager = false,
                hmultiline = false,
                dmultiline = false;
    int         output_columns = 0; /* Width of interactive console */
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 2)
        opt_border = 2;
 
    /*
     * Kluge for totally empty table: use the default footer even though
     * vertical modes normally don't.  Otherwise we'd print nothing at all,
     * which isn't terribly friendly.  Assume pager will not be needed.
     */
    if (cont->cells[0] == NULL && cont->opt->start_table &&
        cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        if (!opt_tuples_only && !cancel_pressed && footers)
        {
            printTableFooter *f;
 
            for (f = footers; f; f = f->next)
                fprintf(fout, "%s\n", f->data);
        }
 
        fputc('\n', fout);
 
        return;
    }
 
    /*
     * Deal with the pager here instead of in printTable(), because we could
     * get here via print_aligned_text() in expanded auto mode, and so we have
     * to recalculate the pager requirement based on vertical output.
     */
    if (!is_pager)
    {
        IsPagerNeeded(cont, NULL, true, &fout, &is_pager);
        is_local_pager = is_pager;
    }
 
    /* Find the maximum dimensions for the headers */
    for (i = 0; i < cont->ncolumns; i++)
    {
        int         width,
                    height,
                    fs;
 
        pg_wcssize((const unsigned char *) cont->headers[i], strlen(cont->headers[i]),
                   encoding, &width, &height, &fs);
        if (width > hwidth)
            hwidth = width;
        if (height > hheight)
        {
            hheight = height;
            hmultiline = true;
        }
        if (fs > hformatsize)
            hformatsize = fs;
    }
 
    /* find longest data cell */
    for (ptr = cont->cells; *ptr; ptr++)
    {
        int         width,
                    height,
                    fs;
 
        pg_wcssize((const unsigned char *) *ptr, strlen(*ptr), encoding,
                   &width, &height, &fs);
        if (width > dwidth)
            dwidth = width;
        if (height > dheight)
        {
            dheight = height;
            dmultiline = true;
        }
        if (fs > dformatsize)
            dformatsize = fs;
    }
 
    /*
     * We now have all the information we need to setup the formatting
     * structures
     */
    dlineptr = pg_malloc_array(struct lineptr, (dheight + 1));
    hlineptr = pg_malloc_array(struct lineptr, (hheight + 1));
 
    dlineptr->ptr = pg_malloc(dformatsize);
    hlineptr->ptr = pg_malloc(hformatsize);
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
            fprintf(fout, "%s\n", cont->title);
    }
 
    /*
     * Choose target output width: \pset columns, or $COLUMNS, or ioctl
     */
    if (cont->opt->columns > 0)
        output_columns = cont->opt->columns;
    else if ((fout == stdout && isatty(fileno(stdout))) || is_pager)
    {
        if (cont->opt->env_columns > 0)
            output_columns = cont->opt->env_columns;
#ifdef TIOCGWINSZ
        else
        {
            struct winsize screen_size;
 
            if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) != -1)
                output_columns = screen_size.ws_col;
        }
#endif
    }
 
    /*
     * Determine data column width: fit output width in wrapped mode, or
     * ensure alignment with the record header line in aligned mode.
     */
    if (cont->opt->format == PRINT_WRAPPED || cont->opt->format == PRINT_ALIGNED)
    {
        unsigned int swidth,
                    rwidth = 0,
                    newdwidth;
 
        if (opt_border == 0)
        {
            /*
             * For border = 0, one space in the middle.  (If we discover we
             * need to wrap, the spacer column will be replaced by a wrap
             * marker, and we'll make room below for another wrap marker at
             * the end of the line.  But for now, assume no wrap is needed.)
             */
            swidth = 1;
 
            /* We might need a column for header newline markers, too */
            if (hmultiline)
                swidth++;
        }
        else if (opt_border == 1)
        {
            /*
             * For border = 1, two spaces and a vrule in the middle.  (As
             * above, we might need one more column for a wrap marker.)
             */
            swidth = 3;
 
            /* We might need a column for left header newline markers, too */
            if (hmultiline && (format == &pg_asciiformat_old))
                swidth++;
        }
        else
        {
            /*
             * For border = 2, two more for the vrules at the beginning and
             * end of the lines, plus spacer columns adjacent to these.  (We
             * won't need extra columns for wrap/newline markers, we'll just
             * repurpose the spacers.)
             */
            swidth = 7;
        }
 
        /* Reserve a column for data newline indicators, too, if needed */
        if (dmultiline &&
            opt_border < 2 && format != &pg_asciiformat_old)
            swidth++;
 
        /* Determine width required for record header lines */
        if (!opt_tuples_only)
        {
            if (cont->nrows > 0)
                rwidth = 1 + (int) log10(cont->nrows);
            if (opt_border == 0)
                rwidth += 9;    /* "* RECORD " */
            else if (opt_border == 1)
                rwidth += 12;   /* "-[ RECORD  ]" */
            else
                rwidth += 15;   /* "+-[ RECORD  ]-+" */
        }
 
        /* We might need to do the rest of the calculation twice */
        for (;;)
        {
            unsigned int width;
 
            /* Total width required to not wrap data */
            width = hwidth + swidth + dwidth;
            /* ... and not the header lines, either */
            if (width < rwidth)
                width = rwidth;
 
            if (cont->opt->format == PRINT_WRAPPED && output_columns > 0)
            {
                unsigned int min_width;
 
                /* Minimum acceptable width: room for just 3 columns of data */
                min_width = hwidth + swidth + 3;
                /* ... but not less than what the record header lines need */
                if (min_width < rwidth)
                    min_width = rwidth;
 
                if (output_columns >= width)
                {
                    /* Plenty of room, use native data width */
                    /* (but at least enough for the record header lines) */
                    newdwidth = width - hwidth - swidth;
                }
                else if (output_columns < min_width)
                {
                    /* Set data width to match min_width */
                    newdwidth = min_width - hwidth - swidth;
                }
                else
                {
                    /* Set data width to match output_columns */
                    newdwidth = output_columns - hwidth - swidth;
                }
            }
            else
            {
                /* Don't know the wrap limit, so use native data width */
                /* (but at least enough for the record header lines) */
                newdwidth = width - hwidth - swidth;
            }
 
            /*
             * If we will need to wrap data and didn't already allocate a data
             * newline/wrap marker column, do so and recompute.
             */
            if (newdwidth < dwidth && !dmultiline &&
                opt_border < 2 && format != &pg_asciiformat_old)
            {
                dmultiline = true;
                swidth++;
            }
            else
                break;
        }
 
        dwidth = newdwidth;
    }
 
    /* print records */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        printTextRule pos;
        int         dline,
                    hline,
                    dcomplete,
                    hcomplete,
                    offset,
                    chars_to_output;
 
        if (cancel_pressed)
            break;
 
        if (i == 0)
            pos = PRINT_RULE_TOP;
        else
            pos = PRINT_RULE_MIDDLE;
 
        /* Print record header (e.g. "[ RECORD N ]") above each record */
        if (i % cont->ncolumns == 0)
        {
            unsigned int lhwidth = hwidth;
 
            if ((opt_border < 2) &&
                (hmultiline) &&
                (format == &pg_asciiformat_old))
                lhwidth++;      /* for newline indicators */
 
            if (!opt_tuples_only)
                print_aligned_vertical_line(cont->opt, record++,
                                            lhwidth, dwidth, output_columns,
                                            pos, fout);
            else if (i != 0 || !cont->opt->start_table || opt_border == 2)
                print_aligned_vertical_line(cont->opt, 0, lhwidth,
                                            dwidth, output_columns, pos, fout);
        }
 
        /* Format the header */
        pg_wcsformat((const unsigned char *) cont->headers[i % cont->ncolumns],
                     strlen(cont->headers[i % cont->ncolumns]),
                     encoding, hlineptr, hheight);
        /* Format the data */
        pg_wcsformat((const unsigned char *) *ptr, strlen(*ptr), encoding,
                     dlineptr, dheight);
 
        /*
         * Loop through header and data in parallel dealing with newlines and
         * wrapped lines until they're both exhausted
         */
        dline = hline = 0;
        dcomplete = hcomplete = 0;
        offset = 0;
        chars_to_output = dlineptr[dline].width;
        while (!dcomplete || !hcomplete)
        {
            /* Left border */
            if (opt_border == 2)
                fprintf(fout, "%s", dformat->leftvrule);
 
            /* Header (never wrapped so just need to deal with newlines) */
            if (!hcomplete)
            {
                int         swidth = hwidth,
                            target_width = hwidth;
 
                /*
                 * Left spacer or new line indicator
                 */
                if ((opt_border == 2) ||
                    (hmultiline && (format == &pg_asciiformat_old)))
                    fputs(hline ? format->header_nl_left : " ", fout);
 
                /*
                 * Header text
                 */
                strlen_max_width(hlineptr[hline].ptr, &target_width,
                                 encoding);
                fprintf(fout, "%-s", hlineptr[hline].ptr);
 
                /*
                 * Spacer
                 */
                swidth -= target_width;
                if (swidth > 0)
                    fprintf(fout, "%*s", swidth, " ");
 
                /*
                 * New line indicator or separator's space
                 */
                if (hlineptr[hline + 1].ptr)
                {
                    /* More lines after this one due to a newline */
                    if ((opt_border > 0) ||
                        (hmultiline && (format != &pg_asciiformat_old)))
                        fputs(format->header_nl_right, fout);
                    hline++;
                }
                else
                {
                    /* This was the last line of the header */
                    if ((opt_border > 0) ||
                        (hmultiline && (format != &pg_asciiformat_old)))
                        fputs(" ", fout);
                    hcomplete = 1;
                }
            }
            else
            {
                unsigned int swidth = hwidth + opt_border;
 
                if ((opt_border < 2) &&
                    (hmultiline) &&
                    (format == &pg_asciiformat_old))
                    swidth++;
 
                if ((opt_border == 0) &&
                    (format != &pg_asciiformat_old) &&
                    (hmultiline))
                    swidth++;
 
                fprintf(fout, "%*s", swidth, " ");
            }
 
            /* Separator */
            if (opt_border > 0)
            {
                if (offset)
                    fputs(format->midvrule_wrap, fout);
                else if (dline == 0)
                    fputs(dformat->midvrule, fout);
                else
                    fputs(format->midvrule_nl, fout);
            }
 
            /* Data */
            if (!dcomplete)
            {
                int         target_width = dwidth,
                            bytes_to_output,
                            swidth = dwidth;
 
                /*
                 * Left spacer or wrap indicator
                 */
                fputs(offset == 0 ? " " : format->wrap_left, fout);
 
                /*
                 * Data text
                 */
                bytes_to_output = strlen_max_width(dlineptr[dline].ptr + offset,
                                                   &target_width, encoding);
                fwrite((char *) (dlineptr[dline].ptr + offset),
                       1, bytes_to_output, fout);
 
                chars_to_output -= target_width;
                offset += bytes_to_output;
 
                /* Spacer */
                swidth -= target_width;
 
                if (chars_to_output)
                {
                    /* continuing a wrapped column */
                    if ((opt_border > 1) ||
                        (dmultiline && (format != &pg_asciiformat_old)))
                    {
                        if (swidth > 0)
                            fprintf(fout, "%*s", swidth, " ");
                        fputs(format->wrap_right, fout);
                    }
                }
                else if (dlineptr[dline + 1].ptr)
                {
                    /* reached a newline in the column */
                    if ((opt_border > 1) ||
                        (dmultiline && (format != &pg_asciiformat_old)))
                    {
                        if (swidth > 0)
                            fprintf(fout, "%*s", swidth, " ");
                        fputs(format->nl_right, fout);
                    }
                    dline++;
                    offset = 0;
                    chars_to_output = dlineptr[dline].width;
                }
                else
                {
                    /* reached the end of the cell */
                    if (opt_border > 1)
                    {
                        if (swidth > 0)
                            fprintf(fout, "%*s", swidth, " ");
                        fputs(" ", fout);
                    }
                    dcomplete = 1;
                }
 
                /* Right border */
                if (opt_border == 2)
                    fputs(dformat->rightvrule, fout);
 
                fputs("\n", fout);
            }
            else
            {
                /*
                 * data exhausted (this can occur if header is longer than the
                 * data due to newlines in the header)
                 */
                if (opt_border < 2)
                    fputs("\n", fout);
                else
                    fprintf(fout, "%*s  %s\n", dwidth, "", dformat->rightvrule);
            }
        }
    }
 
    if (cont->opt->stop_table)
    {
        if (opt_border == 2 && !cancel_pressed)
            print_aligned_vertical_line(cont->opt, 0, hwidth, dwidth,
                                        output_columns, PRINT_RULE_BOTTOM, fout);
 
        /* print footers */
        if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            if (opt_border < 2)
                fputc('\n', fout);
            for (f = cont->footers; f; f = f->next)
                fprintf(fout, "%s\n", f->data);
        }
 
        fputc('\n', fout);
    }
 
    free(hlineptr->ptr);
    free(dlineptr->ptr);
    free(hlineptr);
    free(dlineptr);
 
    if (is_local_pager)
        ClosePager(fout);
}
 
 
/**********************/
/* CSV format         */
/**********************/
 
 
static void
csv_escaped_print(const char *str, FILE *fout)
{
    const char *p;
 
    fputc('"', fout);
    for (p = str; *p; p++)
    {
        if (*p == '"')
            fputc('"', fout);   /* double quotes are doubled */
        fputc(*p, fout);
    }
    fputc('"', fout);
}
 
static void
csv_print_field(const char *str, FILE *fout, char sep)
{
    /*----------------
     * Enclose and escape field contents when one of these conditions is met:
     * - the field separator is found in the contents.
     * - the field contains a CR or LF.
     * - the field contains a double quote.
     * - the field is exactly "\.".
     * - the field separator is either "\" or ".".
     * The last two cases prevent producing a line that the server's COPY
     * command would interpret as an end-of-data marker.  We only really
     * need to ensure that the complete line isn't exactly "\.", but for
     * simplicity we apply stronger restrictions here.
     *----------------
     */
    if (strchr(str, sep) != NULL ||
        strcspn(str, "\r\n\"") != strlen(str) ||
        strcmp(str, "\\.") == 0 ||
        sep == '\\' || sep == '.')
        csv_escaped_print(str, fout);
    else
        fputs(str, fout);
}
 
static void
print_csv_text(const printTableContent *cont, FILE *fout)
{
    const char *const *ptr;
    int         i;
 
    if (cancel_pressed)
        return;
 
    /*
     * The title and footer are never printed in csv format. The header is
     * printed if opt_tuples_only is false.
     *
     * Despite RFC 4180 saying that end of lines are CRLF, terminate lines
     * with '\n', which prints out as the system-dependent EOL string in text
     * mode (typically LF on Unix and CRLF on Windows).
     */
    if (cont->opt->start_table && !cont->opt->tuples_only)
    {
        /* print headers */
        for (ptr = cont->headers; *ptr; ptr++)
        {
            if (ptr != cont->headers)
                fputc(cont->opt->csvFieldSep[0], fout);
            csv_print_field(*ptr, fout, cont->opt->csvFieldSep[0]);
        }
        fputc('\n', fout);
    }
 
    /* print cells */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        csv_print_field(*ptr, fout, cont->opt->csvFieldSep[0]);
        if ((i + 1) % cont->ncolumns)
            fputc(cont->opt->csvFieldSep[0], fout);
        else
            fputc('\n', fout);
    }
}
 
static void
print_csv_vertical(const printTableContent *cont, FILE *fout)
{
    const char *const *ptr;
    int         i;
 
    /* print records */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        if (cancel_pressed)
            return;
 
        /* print name of column */
        csv_print_field(cont->headers[i % cont->ncolumns], fout,
                        cont->opt->csvFieldSep[0]);
 
        /* print field separator */
        fputc(cont->opt->csvFieldSep[0], fout);
 
        /* print field value */
        csv_print_field(*ptr, fout, cont->opt->csvFieldSep[0]);
 
        fputc('\n', fout);
    }
}
 
 
/**********************/
/* HTML               */
/**********************/
 
 
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 printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    const char *opt_table_attr = cont->opt->tableAttr;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (cont->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 && cont->title)
        {
            fputs("  <caption>", fout);
            html_escaped_print(cont->title, fout);
            fputs("</caption>\n", fout);
        }
 
        /* print headers */
        if (!opt_tuples_only)
        {
            fputs("  <tr>\n", fout);
            for (ptr = cont->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 = cont->cells; *ptr; i++, ptr++)
    {
        if (i % cont->ncolumns == 0)
        {
            if (cancel_pressed)
                break;
            fputs("  <tr valign=\"top\">\n", fout);
        }
 
        fprintf(fout, "    <td align=\"%s\">", cont->aligns[(i) % cont->ncolumns] == 'r' ? "right" : "left");
        /* is string only whitespace? */
        if ((*ptr)[strspn(*ptr, " \t")] == '\0')
            fputs("&nbsp; ", fout);
        else
            html_escaped_print(*ptr, fout);
 
        fputs("</td>\n", fout);
 
        if ((i + 1) % cont->ncolumns == 0)
            fputs("  </tr>\n", fout);
    }
 
    if (cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        fputs("</table>\n", fout);
 
        /* print footers */
        if (!opt_tuples_only && footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            fputs("<p>", fout);
            for (f = footers; f; f = f->next)
            {
                html_escaped_print(f->data, fout);
                fputs("<br />\n", fout);
            }
            fputs("</p>", fout);
        }
 
        fputc('\n', fout);
    }
}
 
 
static void
print_html_vertical(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    const char *opt_table_attr = cont->opt->tableAttr;
    unsigned long record = cont->opt->prior_records + 1;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (cont->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 && cont->title)
        {
            fputs("  <caption>", fout);
            html_escaped_print(cont->title, fout);
            fputs("</caption>\n", fout);
        }
    }
 
    /* print records */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        if (i % cont->ncolumns == 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(cont->headers[i % cont->ncolumns], fout);
        fputs("</th>\n", fout);
 
        fprintf(fout, "    <td align=\"%s\">", cont->aligns[i % cont->ncolumns] == 'r' ? "right" : "left");
        /* is string only whitespace? */
        if ((*ptr)[strspn(*ptr, " \t")] == '\0')
            fputs("&nbsp; ", fout);
        else
            html_escaped_print(*ptr, fout);
 
        fputs("</td>\n  </tr>\n", fout);
    }
 
    if (cont->opt->stop_table)
    {
        fputs("</table>\n", fout);
 
        /* print footers */
        if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            fputs("<p>", fout);
            for (f = cont->footers; f; f = f->next)
            {
                html_escaped_print(f->data, fout);
                fputs("<br />\n", fout);
            }
            fputs("</p>", fout);
        }
 
        fputc('\n', fout);
    }
}
 
 
/*************************/
/* ASCIIDOC              */
/*************************/
 
 
static void
asciidoc_escaped_print(const char *in, FILE *fout)
{
    const char *p;
 
    for (p = in; *p; p++)
    {
        switch (*p)
        {
            case '|':
                fputs("\\|", fout);
                break;
            default:
                fputc(*p, fout);
        }
    }
}
 
static void
print_asciidoc_text(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (cont->opt->start_table)
    {
        /* print table in new paragraph - enforce preliminary new line */
        fputs("\n", fout);
 
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs(".", fout);
            fputs(cont->title, fout);
            fputs("\n", fout);
        }
 
        /* print table [] header definition */
        fprintf(fout, "[%scols=\"", !opt_tuples_only ? "options=\"header\"," : "");
        for (i = 0; i < cont->ncolumns; i++)
        {
            if (i != 0)
                fputs(",", fout);
            fprintf(fout, "%s", cont->aligns[(i) % cont->ncolumns] == 'r' ? ">l" : "<l");
        }
        fputs("\"", fout);
        switch (opt_border)
        {
            case 0:
                fputs(",frame=\"none\",grid=\"none\"", fout);
                break;
            case 1:
                fputs(",frame=\"none\"", fout);
                break;
            case 2:
                fputs(",frame=\"all\",grid=\"all\"", fout);
                break;
        }
        fputs("]\n", fout);
        fputs("|====\n", fout);
 
        /* print headers */
        if (!opt_tuples_only)
        {
            for (ptr = cont->headers; *ptr; ptr++)
            {
                if (ptr != cont->headers)
                    fputs(" ", fout);
                fputs("^l|", fout);
                asciidoc_escaped_print(*ptr, fout);
            }
            fputs("\n", fout);
        }
    }
 
    /* print cells */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        if (i % cont->ncolumns == 0)
        {
            if (cancel_pressed)
                break;
        }
 
        if (i % cont->ncolumns != 0)
            fputs(" ", fout);
        fputs("|", fout);
 
        /* protect against needless spaces */
        if ((*ptr)[strspn(*ptr, " \t")] == '\0')
        {
            if ((i + 1) % cont->ncolumns != 0)
                fputs(" ", fout);
        }
        else
            asciidoc_escaped_print(*ptr, fout);
 
        if ((i + 1) % cont->ncolumns == 0)
            fputs("\n", fout);
    }
 
    fputs("|====\n", fout);
 
    if (cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        /* print footers */
        if (!opt_tuples_only && footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            fputs("\n....\n", fout);
            for (f = footers; f; f = f->next)
            {
                fputs(f->data, fout);
                fputs("\n", fout);
            }
            fputs("....\n", fout);
        }
    }
}
 
static void
print_asciidoc_vertical(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned long record = cont->opt->prior_records + 1;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (cont->opt->start_table)
    {
        /* print table in new paragraph - enforce preliminary new line */
        fputs("\n", fout);
 
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs(".", fout);
            fputs(cont->title, fout);
            fputs("\n", fout);
        }
 
        /* print table [] header definition */
        fputs("[cols=\"h,l\"", fout);
        switch (opt_border)
        {
            case 0:
                fputs(",frame=\"none\",grid=\"none\"", fout);
                break;
            case 1:
                fputs(",frame=\"none\"", fout);
                break;
            case 2:
                fputs(",frame=\"all\",grid=\"all\"", fout);
                break;
        }
        fputs("]\n", fout);
        fputs("|====\n", fout);
    }
 
    /* print records */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        if (i % cont->ncolumns == 0)
        {
            if (cancel_pressed)
                break;
            if (!opt_tuples_only)
                fprintf(fout,
                        "2+^|Record %lu\n",
                        record++);
            else
                fputs("2+|\n", fout);
        }
 
        fputs("<l|", fout);
        asciidoc_escaped_print(cont->headers[i % cont->ncolumns], fout);
 
        fprintf(fout, " %s|", cont->aligns[i % cont->ncolumns] == 'r' ? ">l" : "<l");
        /* is string only whitespace? */
        if ((*ptr)[strspn(*ptr, " \t")] == '\0')
            fputs(" ", fout);
        else
            asciidoc_escaped_print(*ptr, fout);
        fputs("\n", fout);
    }
 
    fputs("|====\n", fout);
 
    if (cont->opt->stop_table)
    {
        /* print footers */
        if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed)
        {
            printTableFooter *f;
 
            fputs("\n....\n", fout);
            for (f = cont->footers; f; f = f->next)
            {
                fputs(f->data, fout);
                fputs("\n", fout);
            }
            fputs("....\n", fout);
        }
    }
}
 
 
/*************************/
/* LaTeX                 */
/*************************/
 
 
static void
latex_escaped_print(const char *in, FILE *fout)
{
    const char *p;
 
    for (p = in; *p; p++)
        switch (*p)
        {
                /*
                 * We convert ASCII characters per the recommendations in
                 * Scott Pakin's "The Comprehensive LATEX Symbol List",
                 * available from CTAN.  For non-ASCII, you're on your own.
                 */
            case '#':
                fputs("\\#", fout);
                break;
            case '$':
                fputs("\\$", fout);
                break;
            case '%':
                fputs("\\%", fout);
                break;
            case '&':
                fputs("\\&", fout);
                break;
            case '<':
                fputs("\\textless{}", fout);
                break;
            case '>':
                fputs("\\textgreater{}", fout);
                break;
            case '\\':
                fputs("\\textbackslash{}", fout);
                break;
            case '^':
                fputs("\\^{}", fout);
                break;
            case '_':
                fputs("\\_", fout);
                break;
            case '{':
                fputs("\\{", fout);
                break;
            case '|':
                fputs("\\textbar{}", fout);
                break;
            case '}':
                fputs("\\}", fout);
                break;
            case '~':
                fputs("\\~{}", fout);
                break;
            case '\n':
                /* This is not right, but doing it right seems too hard */
                fputs("\\\\", fout);
                break;
            default:
                fputc(*p, fout);
        }
}
 
 
static void
print_latex_text(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 3)
        opt_border = 3;
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs("\\begin{center}\n", fout);
            latex_escaped_print(cont->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 < cont->ncolumns; i++)
        {
            fputc(*(cont->aligns + i), fout);
            if (opt_border != 0 && i < cont->ncolumns - 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 = cont->headers; i < cont->ncolumns; 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 = cont->cells; *ptr; i++, ptr++)
    {
        latex_escaped_print(*ptr, fout);
 
        if ((i + 1) % cont->ncolumns == 0)
        {
            fputs(" \\\\\n", fout);
            if (opt_border == 3)
                fputs("\\hline\n", fout);
            if (cancel_pressed)
                break;
        }
        else
            fputs(" & ", fout);
    }
 
    if (cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        if (opt_border == 2)
            fputs("\\hline\n", fout);
 
        fputs("\\end{tabular}\n\n\\noindent ", fout);
 
        /* print footers */
        if (footers && !opt_tuples_only && !cancel_pressed)
        {
            printTableFooter *f;
 
            for (f = footers; f; f = f->next)
            {
                latex_escaped_print(f->data, fout);
                fputs(" \\\\\n", fout);
            }
        }
 
        fputc('\n', fout);
    }
}
 
 
/*************************/
/* LaTeX longtable       */
/*************************/
 
 
static void
print_latex_longtable_text(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned int i;
    const char *opt_table_attr = cont->opt->tableAttr;
    const char *next_opt_table_attr_char = opt_table_attr;
    const char *last_opt_table_attr_char = NULL;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 3)
        opt_border = 3;
 
    if (cont->opt->start_table)
    {
        /* begin environment and set alignments and borders */
        fputs("\\begin{longtable}{", fout);
 
        if (opt_border >= 2)
            fputs("| ", fout);
 
        for (i = 0; i < cont->ncolumns; i++)
        {
            /* longtable supports either a width (p) or an alignment (l/r) */
            /* Are we left-justified and was a proportional width specified? */
            if (*(cont->aligns + i) == 'l' && opt_table_attr)
            {
#define LONGTABLE_WHITESPACE    " \t\n"
 
                /* advance over whitespace */
                next_opt_table_attr_char += strspn(next_opt_table_attr_char,
                                                   LONGTABLE_WHITESPACE);
                /* We have a value? */
                if (next_opt_table_attr_char[0] != '\0')
                {
                    fputs("p{", fout);
                    fwrite(next_opt_table_attr_char, strcspn(next_opt_table_attr_char,
                                                             LONGTABLE_WHITESPACE), 1, fout);
                    last_opt_table_attr_char = next_opt_table_attr_char;
                    next_opt_table_attr_char += strcspn(next_opt_table_attr_char,
                                                        LONGTABLE_WHITESPACE);
                    fputs("\\textwidth}", fout);
                }
                /* use previous value */
                else if (last_opt_table_attr_char != NULL)
                {
                    fputs("p{", fout);
                    fwrite(last_opt_table_attr_char, strcspn(last_opt_table_attr_char,
                                                             LONGTABLE_WHITESPACE), 1, fout);
                    fputs("\\textwidth}", fout);
                }
                else
                    fputc('l', fout);
            }
            else
                fputc(*(cont->aligns + i), fout);
 
            if (opt_border != 0 && i < cont->ncolumns - 1)
                fputs(" | ", fout);
        }
 
        if (opt_border >= 2)
            fputs(" |", fout);
 
        fputs("}\n", fout);
 
        /* print headers */
        if (!opt_tuples_only)
        {
            /* firsthead */
            if (opt_border >= 2)
                fputs("\\toprule\n", fout);
            for (i = 0, ptr = cont->headers; i < cont->ncolumns; i++, ptr++)
            {
                if (i != 0)
                    fputs(" & ", fout);
                fputs("\\small\\textbf{\\textit{", fout);
                latex_escaped_print(*ptr, fout);
                fputs("}}", fout);
            }
            fputs(" \\\\\n", fout);
            fputs("\\midrule\n\\endfirsthead\n", fout);
 
            /* secondary heads */
            if (opt_border >= 2)
                fputs("\\toprule\n", fout);
            for (i = 0, ptr = cont->headers; i < cont->ncolumns; i++, ptr++)
            {
                if (i != 0)
                    fputs(" & ", fout);
                fputs("\\small\\textbf{\\textit{", fout);
                latex_escaped_print(*ptr, fout);
                fputs("}}", fout);
            }
            fputs(" \\\\\n", fout);
            /* If the line under the row already appeared, don't do another */
            if (opt_border != 3)
                fputs("\\midrule\n", fout);
            fputs("\\endhead\n", fout);
 
            /* table name, caption? */
            if (!opt_tuples_only && cont->title)
            {
                /* Don't output if we are printing a line under each row */
                if (opt_border == 2)
                    fputs("\\bottomrule\n", fout);
                fputs("\\caption[", fout);
                latex_escaped_print(cont->title, fout);
                fputs(" (Continued)]{", fout);
                latex_escaped_print(cont->title, fout);
                fputs("}\n\\endfoot\n", fout);
                if (opt_border == 2)
                    fputs("\\bottomrule\n", fout);
                fputs("\\caption[", fout);
                latex_escaped_print(cont->title, fout);
                fputs("]{", fout);
                latex_escaped_print(cont->title, fout);
                fputs("}\n\\endlastfoot\n", fout);
            }
            /* output bottom table line? */
            else if (opt_border >= 2)
            {
                fputs("\\bottomrule\n\\endfoot\n", fout);
                fputs("\\bottomrule\n\\endlastfoot\n", fout);
            }
        }
    }
 
    /* print cells */
    for (i = 0, ptr = cont->cells; *ptr; i++, ptr++)
    {
        /* Add a line under each row? */
        if (i != 0 && i % cont->ncolumns != 0)
            fputs("\n&\n", fout);
        fputs("\\raggedright{", fout);
        latex_escaped_print(*ptr, fout);
        fputc('}', fout);
        if ((i + 1) % cont->ncolumns == 0)
        {
            fputs(" \\tabularnewline\n", fout);
            if (opt_border == 3)
                fputs(" \\hline\n", fout);
        }
        if (cancel_pressed)
            break;
    }
 
    if (cont->opt->stop_table)
        fputs("\\end{longtable}\n", fout);
}
 
 
static void
print_latex_vertical(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned long record = cont->opt->prior_records + 1;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 2)
        opt_border = 2;
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs("\\begin{center}\n", fout);
            latex_escaped_print(cont->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 = cont->cells; *ptr; i++, ptr++)
    {
        /* new record */
        if (i % cont->ncolumns == 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(cont->headers[i % cont->ncolumns], fout);
        fputs(" & ", fout);
        latex_escaped_print(*ptr, fout);
        fputs(" \\\\\n", fout);
    }
 
    if (cont->opt->stop_table)
    {
        if (opt_border == 2)
            fputs("\\hline\n", fout);
 
        fputs("\\end{tabular}\n\n\\noindent ", fout);
 
        /* print footers */
        if (cont->footers && !opt_tuples_only && !cancel_pressed)
        {
            printTableFooter *f;
 
            for (f = cont->footers; f; f = f->next)
            {
                latex_escaped_print(f->data, 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 printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned int i;
    const char *const *ptr;
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 2)
        opt_border = 2;
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs(".LP\n.DS C\n", fout);
            troff_ms_escaped_print(cont->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 < cont->ncolumns; i++)
        {
            fputc(*(cont->aligns + i), fout);
            if (opt_border > 0 && i < cont->ncolumns - 1)
                fputs(" | ", fout);
        }
        fputs(".\n", fout);
 
        /* print headers */
        if (!opt_tuples_only)
        {
            for (i = 0, ptr = cont->headers; i < cont->ncolumns; 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 = cont->cells; *ptr; i++, ptr++)
    {
        troff_ms_escaped_print(*ptr, fout);
 
        if ((i + 1) % cont->ncolumns == 0)
        {
            fputc('\n', fout);
            if (cancel_pressed)
                break;
        }
        else
            fputc('\t', fout);
    }
 
    if (cont->opt->stop_table)
    {
        printTableFooter *footers = footers_with_default(cont);
 
        fputs(".TE\n.DS L\n", fout);
 
        /* print footers */
        if (footers && !opt_tuples_only && !cancel_pressed)
        {
            printTableFooter *f;
 
            for (f = footers; f; f = f->next)
            {
                troff_ms_escaped_print(f->data, fout);
                fputc('\n', fout);
            }
        }
 
        fputs(".DE\n", fout);
    }
}
 
 
static void
print_troff_ms_vertical(const printTableContent *cont, FILE *fout)
{
    bool        opt_tuples_only = cont->opt->tuples_only;
    unsigned short opt_border = cont->opt->border;
    unsigned long record = cont->opt->prior_records + 1;
    unsigned int i;
    const char *const *ptr;
    unsigned short current_format = 0;  /* 0=none, 1=header, 2=body */
 
    if (cancel_pressed)
        return;
 
    if (opt_border > 2)
        opt_border = 2;
 
    if (cont->opt->start_table)
    {
        /* print title */
        if (!opt_tuples_only && cont->title)
        {
            fputs(".LP\n.DS C\n", fout);
            troff_ms_escaped_print(cont->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 = cont->cells; *ptr; i++, ptr++)
    {
        /* new record */
        if (i % cont->ncolumns == 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(cont->headers[i % cont->ncolumns], fout);
        fputc('\t', fout);
        troff_ms_escaped_print(*ptr, fout);
 
        fputc('\n', fout);
    }
 
    if (cont->opt->stop_table)
    {
        fputs(".TE\n.DS L\n", fout);
 
        /* print footers */
        if (cont->footers && !opt_tuples_only && !cancel_pressed)
        {
            printTableFooter *f;
 
            for (f = cont->footers; f; f = f->next)
            {
                troff_ms_escaped_print(f->data, fout);
                fputc('\n', fout);
            }
        }
 
        fputs(".DE\n", fout);
    }
}
 
 
/********************************/
/* Public functions             */
/********************************/
 
 
/*
 * disable_sigpipe_trap
 *
 * Turn off SIGPIPE interrupt --- call this before writing to a temporary
 * query output file that is a pipe.
 *
 * No-op on Windows, where there's no SIGPIPE interrupts.
 */
void
disable_sigpipe_trap(void)
{
#ifndef WIN32
    pqsignal(SIGPIPE, PG_SIG_IGN);
#endif
}
 
/*
 * restore_sigpipe_trap
 *
 * Restore normal SIGPIPE interrupt --- call this when done writing to a
 * temporary query output file that was (or might have been) a pipe.
 *
 * Note: within psql, we enable SIGPIPE interrupts unless the permanent query
 * output file is a pipe, in which case they should be kept off.  This
 * approach works only because psql is not currently complicated enough to
 * have nested usages of short-lived output files.  Otherwise we'd probably
 * need a genuine save-and-restore-state approach; but for now, that would be
 * useless complication.  In non-psql programs, this always enables SIGPIPE.
 *
 * No-op on Windows, where there's no SIGPIPE interrupts.
 */
void
restore_sigpipe_trap(void)
{
#ifndef WIN32
    pqsignal(SIGPIPE, always_ignore_sigpipe ? PG_SIG_IGN : PG_SIG_DFL);
#endif
}
 
/*
 * set_sigpipe_trap_state
 *
 * Set the trap state that restore_sigpipe_trap should restore to.
 */
void
set_sigpipe_trap_state(bool ignore)
{
    always_ignore_sigpipe = ignore;
}
 
 
/*
 * PageOutput
 *
 * Tests if pager is needed and returns appropriate FILE pointer
 * (either a pipe, or stdout if we don't need the pager).
 *
 * lines: number of lines that will be printed
 * topt: print formatting options
 *
 * If the topt argument is NULL no pager is used.
 */
FILE *
PageOutput(int lines, const printTableOpt *topt)
{
    return PageOutputInternal(lines, topt, NULL, NULL, false);
}
 
/*
 * Private version that allows for line-counting to be avoided when
 * not needed.  If "cont" is not null then the input value of "lines"
 * is ignored and we count lines based on cont + width_wrap + vertical
 * (see count_table_lines).
 */
static FILE *
PageOutputInternal(int lines, const printTableOpt *topt,
                   const printTableContent *cont,
                   const unsigned int *width_wrap,
                   bool vertical)
{
    /* check whether we need / can / are supposed to use pager */
    if (topt && topt->pager && isatty(fileno(stdin)) && isatty(fileno(stdout)))
    {
        /* without TIOCGWINSZ, pager == 1 acts the same as pager > 1 */
#ifdef TIOCGWINSZ
        unsigned short int pager = topt->pager;
        int         min_lines = topt->pager_min_lines;
 
        if (pager == 1)
        {
            int         result;
            struct winsize screen_size;
 
            result = ioctl(fileno(stdout), TIOCGWINSZ, &screen_size);
            if (result < 0)
                pager = 2;      /* force use of pager */
            else
            {
                int         threshold = Max(screen_size.ws_row, min_lines);
 
                if (cont)       /* caller wants us to calculate lines */
                    lines = count_table_lines(cont, width_wrap, vertical,
                                              threshold);
                /* >= accounts for a one-line prompt */
                if (lines >= threshold)
                    pager = 2;
            }
        }
 
        if (pager > 1)
#endif
        {
            const char *pagerprog;
            FILE       *pagerpipe;
 
            pagerprog = getenv("PSQL_PAGER");
            if (!pagerprog)
                pagerprog = getenv("PAGER");
            if (!pagerprog)
                pagerprog = DEFAULT_PAGER;
            else
            {
                /* if PAGER is empty or all-white-space, don't use pager */
                if (strspn(pagerprog, " \t\r\n") == strlen(pagerprog))
                    return stdout;
            }
            fflush(NULL);
            disable_sigpipe_trap();
            pagerpipe = popen(pagerprog, "w");
            if (pagerpipe)
                return pagerpipe;
            /* if popen fails, silently proceed without pager */
            restore_sigpipe_trap();
        }
    }
 
    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);
        restore_sigpipe_trap();
    }
}
 
/*
 * Initialise a table contents struct.
 *      Must be called before any other printTable method is used.
 *
 * The title is not duplicated; the caller must ensure that the buffer
 * is available for the lifetime of the printTableContent struct.
 *
 * If you call this, you must call printTableCleanup once you're done with the
 * table.
 */
void
printTableInit(printTableContent *const content, const printTableOpt *opt,
               const char *title, const int ncolumns, const int nrows)
{
    uint64      total_cells;
 
    content->opt = opt;
    content->title = title;
    content->ncolumns = ncolumns;
    content->nrows = nrows;
 
    content->headers = pg_malloc0_array(const char *, (ncolumns + 1));
 
    total_cells = (uint64) ncolumns * nrows;
    /* Catch possible overflow.  Using >= here allows adding 1 below */
    if (total_cells >= SIZE_MAX / sizeof(*content->cells))
    {
        fprintf(stderr, _("Cannot print table contents: number of cells %" PRIu64 " is equal to or exceeds maximum %zu.\n"),
                total_cells,
                SIZE_MAX / sizeof(*content->cells));
        exit(EXIT_FAILURE);
    }
    content->cells = pg_malloc0_array(const char *, (total_cells + 1));
 
    content->cellmustfree = NULL;
    content->footers = NULL;
 
    content->aligns = pg_malloc0_array(char, (ncolumns + 1));
 
    content->header = content->headers;
    content->cell = content->cells;
    content->footer = content->footers;
    content->align = content->aligns;
    content->cellsadded = 0;
}
 
/*
 * Add a header to the table.
 *
 * Headers are not duplicated; you must ensure that the header string is
 * available for the lifetime of the printTableContent struct.
 *
 * If translate is true, the function will pass the header through gettext.
 * Otherwise, the header will not be translated.
 *
 * align is either 'l' or 'r', and specifies the alignment for cells in this
 * column.
 */
void
printTableAddHeader(printTableContent *const content, char *header,
                    const bool translate, const char align)
{
#ifndef ENABLE_NLS
    (void) translate;           /* unused parameter */
#endif
 
    if (content->header >= content->headers + content->ncolumns)
    {
        fprintf(stderr, _("Cannot add header to table content: "
                          "column count of %d exceeded.\n"),
                content->ncolumns);
        exit(EXIT_FAILURE);
    }
 
    *content->header = (char *) mbvalidate((unsigned char *) header,
                                           content->opt->encoding);
#ifdef ENABLE_NLS
    if (translate)
        *content->header = _(*content->header);
#endif
    content->header++;
 
    *content->align = align;
    content->align++;
}
 
/*
 * Add a cell to the table.
 *
 * Cells are not duplicated; you must ensure that the cell string is available
 * for the lifetime of the printTableContent struct.
 *
 * If translate is true, the function will pass the cell through gettext.
 * Otherwise, the cell will not be translated.
 *
 * If mustfree is true, the cell string is freed by printTableCleanup().
 * Note: Automatic freeing of translatable strings is not supported.
 */
void
printTableAddCell(printTableContent *const content, char *cell,
                  const bool translate, const bool mustfree)
{
    uint64      total_cells;
 
#ifndef ENABLE_NLS
    (void) translate;           /* unused parameter */
#endif
 
    total_cells = (uint64) content->ncolumns * content->nrows;
    if (content->cellsadded >= total_cells)
    {
        fprintf(stderr, _("Cannot add cell to table content: total cell count of %" PRIu64 " exceeded.\n"),
                total_cells);
        exit(EXIT_FAILURE);
    }
 
    *content->cell = (char *) mbvalidate((unsigned char *) cell,
                                         content->opt->encoding);
 
#ifdef ENABLE_NLS
    if (translate)
        *content->cell = _(*content->cell);
#endif
 
    if (mustfree)
    {
        if (content->cellmustfree == NULL)
            content->cellmustfree =
                pg_malloc0_array(bool, (total_cells + 1));
 
        content->cellmustfree[content->cellsadded] = true;
    }
    content->cell++;
    content->cellsadded++;
}
 
/*
 * Add a footer to the table.
 *
 * Footers are added as elements of a singly-linked list, and the content is
 * strdup'd, so there is no need to keep the original footer string around.
 *
 * Footers are never translated by the function.  If you want the footer
 * translated you must do so yourself, before calling printTableAddFooter.  The
 * reason this works differently to headers and cells is that footers tend to
 * be made of up individually translated components, rather than being
 * translated as a whole.
 */
void
printTableAddFooter(printTableContent *const content, const char *footer)
{
    printTableFooter *f;
 
    f = pg_malloc0_object(printTableFooter);
    f->data = pg_strdup(footer);
 
    if (content->footers == NULL)
        content->footers = f;
    else
        content->footer->next = f;
 
    content->footer = f;
}
 
/*
 * Change the content of the last-added footer.
 *
 * The current contents of the last-added footer are freed, and replaced by the
 * content given in *footer.  If there was no previous footer, add a new one.
 *
 * The content is strdup'd, so there is no need to keep the original string
 * around.
 */
void
printTableSetFooter(printTableContent *const content, const char *footer)
{
    if (content->footers != NULL)
    {
        free(content->footer->data);
        content->footer->data = pg_strdup(footer);
    }
    else
        printTableAddFooter(content, footer);
}
 
/*
 * Free all memory allocated to this struct.
 *
 * Once this has been called, the struct is unusable unless you pass it to
 * printTableInit() again.
 */
void
printTableCleanup(printTableContent *const content)
{
    if (content->cellmustfree)
    {
        uint64      total_cells;
 
        total_cells = (uint64) content->ncolumns * content->nrows;
        for (uint64 i = 0; i < total_cells; i++)
        {
            if (content->cellmustfree[i])
                free(unconstify(char *, content->cells[i]));
        }
        free(content->cellmustfree);
        content->cellmustfree = NULL;
    }
    free(content->headers);
    free(content->cells);
    free(content->aligns);
 
    content->opt = NULL;
    content->title = NULL;
    content->headers = NULL;
    content->cells = NULL;
    content->aligns = NULL;
    content->header = NULL;
    content->cell = NULL;
    content->align = NULL;
 
    if (content->footers)
    {
        for (content->footer = content->footers; content->footer;)
        {
            printTableFooter *f;
 
            f = content->footer;
            content->footer = f->next;
            free(f->data);
            free(f);
        }
    }
    content->footers = NULL;
    content->footer = NULL;
}
 
/*
 * IsPagerNeeded
 *
 * Setup pager if required
 *
 * cont: table data to be printed
 * width_wrap[]: per-column maximum width, or NULL if caller will not wrap
 * vertical: vertical mode?
 * fout: where to print to (in/out argument)
 * is_pager: output argument
 *
 * If we decide pager is needed, *fout is modified and *is_pager is set true
 */
static void
IsPagerNeeded(const printTableContent *cont, const unsigned int *width_wrap,
              bool vertical,
              FILE **fout, bool *is_pager)
{
    if (*fout == stdout)
    {
        *fout = PageOutputInternal(0, cont->opt, cont, width_wrap, vertical);
        *is_pager = (*fout != stdout);
    }
    else
        *is_pager = false;
}
 
/*
 * Count the number of lines needed to print the given table.
 *
 * cont: table data to be printed
 * width_wrap[]: per-column maximum width, or NULL if caller will not wrap
 * vertical: vertical mode?
 * threshold: we can stop counting once we pass this many lines
 *
 * The result is currently only fully accurate for ALIGNED/WRAPPED and
 * UNALIGNED formats; otherwise it's an approximation.
 *
 * Note: while cont->opt will tell us most formatting details, we need the
 * separate "vertical" flag because of the possibility of a dynamic switch
 * from aligned_text to aligned_vertical format.
 *
 * The point of the threshold parameter is that when the table is very long,
 * we'll typically be able to stop scanning after not many rows.
 */
#ifdef NEED_COUNT_TABLE_LINES
static int
count_table_lines(const printTableContent *cont,
                  const unsigned int *width_wrap,
                  bool vertical,
                  int threshold)
{
    int        *header_height;
    int         lines = 0,
                max_lines = 0,
                nl_lines,
                i;
    int         encoding = cont->opt->encoding;
    const char *const *cell;
 
    /*
     * Scan all column headers and determine their heights.  Cache the values
     * since vertical mode repeats the headers for every record.
     */
    header_height = pg_malloc_array(int, cont->ncolumns);
    for (i = 0; i < cont->ncolumns; i++)
    {
        pg_wcssize((const unsigned char *) cont->headers[i],
                   strlen(cont->headers[i]), encoding,
                   NULL, &header_height[i], NULL);
    }
 
    /*
     * Account for separator lines (if used), as well as the trailing blank
     * line that most formats emit.
     */
    switch (cont->opt->format)
    {
        case PRINT_ALIGNED:
        case PRINT_WRAPPED:
 
            /*
             * Vertical mode writes one separator line per record.  Normal
             * mode writes a single separator line between header and rows.
             */
            lines = vertical ? cont->nrows : 1;
            /* Both modes add a blank line at the end */
            lines++;
            break;
        case PRINT_UNALIGNED:
 
            /*
             * Vertical mode writes a separator (here assumed to be a newline)
             * between records.  Normal mode writes nothing extra.
             */
            if (vertical)
                lines = Max(cont->nrows - 1, 0);
            break;
        case PRINT_CSV:
            /* Nothing extra is added */
            break;
        case PRINT_HTML:
        case PRINT_ASCIIDOC:
        case PRINT_LATEX:
        case PRINT_LATEX_LONGTABLE:
        case PRINT_TROFF_MS:
 
            /*
             * These formats aren't really meant for interactive consumption,
             * so for now we won't work hard on them.  Treat them like aligned
             * mode.
             */
            lines = vertical ? cont->nrows : 1;
            lines++;
            break;
        case PRINT_NOTHING:
            /* Shouldn't get here... */
            break;
    }
 
    /* Scan all cells to count their lines */
    for (i = 0, cell = cont->cells; *cell; cell++)
    {
        int         width;
 
        /* Count the original line breaks */
        pg_wcssize((const unsigned char *) *cell, strlen(*cell), encoding,
                   &width, &nl_lines, NULL);
 
        /* Count extra lines due to wrapping */
        if (width > 0 && width_wrap && width_wrap[i])
            nl_lines += (width - 1) / width_wrap[i];
 
        if (vertical)
        {
            /* Pick the height of the header or cell, whichever is taller */
            if (nl_lines > header_height[i])
                lines += nl_lines;
            else
                lines += header_height[i];
        }
        else
        {
            /* Remember max height in the current row */
            if (nl_lines > max_lines)
                max_lines = nl_lines;
        }
 
        /* i is the current column number: increment with wrap */
        if (++i >= cont->ncolumns)
        {
            i = 0;
            if (!vertical)
            {
                /* At last column of each row, add tallest column height */
                lines += max_lines;
                max_lines = 0;
            }
            /* Stop scanning table body once we pass threshold */
            if (lines > threshold)
                break;
        }
    }
 
    /* Account for header and footer decoration */
    if (!cont->opt->tuples_only && lines <= threshold)
    {
        printTableFooter *f;
 
        if (cont->title)
        {
            /* Add height of title */
            pg_wcssize((const unsigned char *) cont->title, strlen(cont->title),
                       encoding, NULL, &nl_lines, NULL);
            lines += nl_lines;
        }
 
        if (!vertical)
        {
            /* Add height of tallest header column */
            max_lines = 0;
            for (i = 0; i < cont->ncolumns; i++)
            {
                if (header_height[i] > max_lines)
                    max_lines = header_height[i];
            }
            lines += max_lines;
        }
 
        /*
         * Add all footer lines.  Vertical mode does not use the default
         * footer, but we must include that in normal mode.
         */
        for (f = (vertical ? cont->footers : footers_with_default(cont));
             f != NULL; f = f->next)
        {
            pg_wcssize((const unsigned char *) f->data, strlen(f->data),
                       encoding, NULL, &nl_lines, NULL);
            lines += nl_lines;
            /* Stop scanning footers once we pass threshold */
            if (lines > threshold)
                break;
        }
    }
 
    free(header_height);
 
    return lines;
}
#endif                          /* NEED_COUNT_TABLE_LINES */
 
/*
 * Use this to print any table in the supported formats.
 *
 * cont: table data and formatting options
 * fout: where to print to
 * is_pager: true if caller has already redirected fout to be a pager pipe
 * flog: if not null, also print the table there (for --log-file option)
 */
void
printTable(const printTableContent *cont,
           FILE *fout, bool is_pager, FILE *flog)
{
    bool        is_local_pager = false;
 
    if (cancel_pressed)
        return;
 
    if (cont->opt->format == PRINT_NOTHING)
        return;
 
    /* print_aligned_*() handle the pager themselves */
    if (!is_pager &&
        cont->opt->format != PRINT_ALIGNED &&
        cont->opt->format != PRINT_WRAPPED)
    {
        IsPagerNeeded(cont, NULL, (cont->opt->expanded == 1), &fout, &is_pager);
        is_local_pager = is_pager;
    }
 
    /* clear any pre-existing error indication on the output stream */
    clearerr(fout);
 
    /* print the stuff */
    switch (cont->opt->format)
    {
        case PRINT_UNALIGNED:
            if (cont->opt->expanded == 1)
                print_unaligned_vertical(cont, fout);
            else
                print_unaligned_text(cont, fout);
            break;
        case PRINT_ALIGNED:
        case PRINT_WRAPPED:
 
            /*
             * In expanded-auto mode, force vertical if a pager is passed in;
             * else we may make different decisions for different hunks of the
             * query result.
             */
            if (cont->opt->expanded == 1 ||
                (cont->opt->expanded == 2 && is_pager))
                print_aligned_vertical(cont, fout, is_pager);
            else
                print_aligned_text(cont, fout, is_pager);
            break;
        case PRINT_CSV:
            if (cont->opt->expanded == 1)
                print_csv_vertical(cont, fout);
            else
                print_csv_text(cont, fout);
            break;
        case PRINT_HTML:
            if (cont->opt->expanded == 1)
                print_html_vertical(cont, fout);
            else
                print_html_text(cont, fout);
            break;
        case PRINT_ASCIIDOC:
            if (cont->opt->expanded == 1)
                print_asciidoc_vertical(cont, fout);
            else
                print_asciidoc_text(cont, fout);
            break;
        case PRINT_LATEX:
            if (cont->opt->expanded == 1)
                print_latex_vertical(cont, fout);
            else
                print_latex_text(cont, fout);
            break;
        case PRINT_LATEX_LONGTABLE:
            if (cont->opt->expanded == 1)
                print_latex_vertical(cont, fout);
            else
                print_latex_longtable_text(cont, fout);
            break;
        case PRINT_TROFF_MS:
            if (cont->opt->expanded == 1)
                print_troff_ms_vertical(cont, fout);
            else
                print_troff_ms_text(cont, fout);
            break;
        default:
            fprintf(stderr, _("invalid output format (internal error): %d"),
                    cont->opt->format);
            exit(EXIT_FAILURE);
    }
 
    if (is_local_pager)
        ClosePager(fout);
 
    /* also produce log output if wanted */
    if (flog)
        print_aligned_text(cont, flog, false);
}
 
/*
 * Use this to print query results
 *
 * result: result of a successful query
 * opt: formatting options
 * fout: where to print to
 * is_pager: true if caller has already redirected fout to be a pager pipe
 * flog: if not null, also print the data there (for --log-file option)
 */
void
printQuery(const PGresult *result, const printQueryOpt *opt,
           FILE *fout, bool is_pager, FILE *flog)
{
    printTableContent cont;
    int         i,
                r,
                c;
 
    if (cancel_pressed)
        return;
 
    printTableInit(&cont, &opt->topt, opt->title,
                   PQnfields(result), PQntuples(result));
 
    /* Assert caller supplied enough translate_columns[] entries */
    Assert(opt->translate_columns == NULL ||
           opt->n_translate_columns >= cont.ncolumns);
 
    for (i = 0; i < cont.ncolumns; i++)
    {
        printTableAddHeader(&cont, PQfname(result, i),
                            opt->translate_header,
                            column_type_alignment(PQftype(result, i)));
    }
 
    /* set cells */
    for (r = 0; r < cont.nrows; r++)
    {
        for (c = 0; c < cont.ncolumns; c++)
        {
            char       *cell;
            bool        mustfree = false;
            bool        translate;
 
            if (PQgetisnull(result, r, c))
                cell = opt->nullPrint ? opt->nullPrint : "";
            else if (PQftype(result, c) == BOOLOID)
                cell = (PQgetvalue(result, r, c)[0] == 't' ?
                        (opt->truePrint ? opt->truePrint : "t") :
                        (opt->falsePrint ? opt->falsePrint : "f"));
            else
            {
                cell = PQgetvalue(result, r, c);
                if (cont.aligns[c] == 'r' && opt->topt.numericLocale)
                {
                    cell = format_numeric_locale(cell);
                    mustfree = true;
                }
            }
 
            translate = (opt->translate_columns && opt->translate_columns[c]);
            printTableAddCell(&cont, cell, translate, mustfree);
        }
    }
 
    /* set footers */
    if (opt->footers)
    {
        char      **footer;
 
        for (footer = opt->footers; *footer; footer++)
            printTableAddFooter(&cont, *footer);
    }
 
    printTable(&cont, fout, is_pager, flog);
    printTableCleanup(&cont);
}
 
char
column_type_alignment(Oid ftype)
{
    char        align;
 
    switch (ftype)
    {
        case INT2OID:
        case INT4OID:
        case INT8OID:
        case FLOAT4OID:
        case FLOAT8OID:
        case NUMERICOID:
        case OIDOID:
        case OID8OID:
        case XIDOID:
        case XID8OID:
        case CIDOID:
        case MONEYOID:
            align = 'r';
            break;
        default:
            align = 'l';
            break;
    }
    return align;
}
 
void
setDecimalLocale(void)
{
    struct lconv *extlconv;
 
    extlconv = localeconv();
 
    /* Don't accept an empty decimal_point string */
    if (*extlconv->decimal_point)
        decimal_point = pg_strdup(extlconv->decimal_point);
    else
        decimal_point = ".";    /* SQL output standard */
 
    /*
     * Although the Open Group standard allows locales to supply more than one
     * group width, we consider only the first one, and we ignore any attempt
     * to suppress grouping by specifying CHAR_MAX.  As in the backend's
     * cash.c, we must apply a range check to avoid being fooled by variant
     * CHAR_MAX values.
     */
    groupdigits = *extlconv->grouping;
    if (groupdigits <= 0 || groupdigits > 6)
        groupdigits = 3;        /* most common */
 
    /* Don't accept an empty thousands_sep string, either */
    /* similar code exists in formatting.c */
    if (*extlconv->thousands_sep)
        thousands_sep = pg_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 = ".";
}
 
/* get selected or default line style */
const printTextFormat *
get_line_style(const printTableOpt *opt)
{
    /*
     * Note: this function mainly exists to preserve the convention that a
     * printTableOpt struct can be initialized to zeroes to get default
     * behavior.
     */
    if (opt->line_style != NULL)
        return opt->line_style;
    else
        return &pg_asciiformat;
}
 
void
refresh_utf8format(const printTableOpt *opt)
{
    printTextFormat *popt = &pg_utf8format;
 
    const unicodeStyleBorderFormat *border;
    const unicodeStyleRowFormat *header;
    const unicodeStyleColumnFormat *column;
 
    popt->name = "unicode";
 
    border = &unicode_style.border_style[opt->unicode_border_linestyle];
    header = &unicode_style.row_style[opt->unicode_header_linestyle];
    column = &unicode_style.column_style[opt->unicode_column_linestyle];
 
    popt->lrule[PRINT_RULE_TOP].hrule = border->horizontal;
    popt->lrule[PRINT_RULE_TOP].leftvrule = border->down_and_right;
    popt->lrule[PRINT_RULE_TOP].midvrule = column->down_and_horizontal[opt->unicode_border_linestyle];
    popt->lrule[PRINT_RULE_TOP].rightvrule = border->down_and_left;
 
    popt->lrule[PRINT_RULE_MIDDLE].hrule = header->horizontal;
    popt->lrule[PRINT_RULE_MIDDLE].leftvrule = header->vertical_and_right[opt->unicode_border_linestyle];
    popt->lrule[PRINT_RULE_MIDDLE].midvrule = column->vertical_and_horizontal[opt->unicode_header_linestyle];
    popt->lrule[PRINT_RULE_MIDDLE].rightvrule = header->vertical_and_left[opt->unicode_border_linestyle];
 
    popt->lrule[PRINT_RULE_BOTTOM].hrule = border->horizontal;
    popt->lrule[PRINT_RULE_BOTTOM].leftvrule = border->up_and_right;
    popt->lrule[PRINT_RULE_BOTTOM].midvrule = column->up_and_horizontal[opt->unicode_border_linestyle];
    popt->lrule[PRINT_RULE_BOTTOM].rightvrule = border->left_and_right;
 
    /* N/A */
    popt->lrule[PRINT_RULE_DATA].hrule = "";
    popt->lrule[PRINT_RULE_DATA].leftvrule = border->vertical;
    popt->lrule[PRINT_RULE_DATA].midvrule = column->vertical;
    popt->lrule[PRINT_RULE_DATA].rightvrule = border->vertical;
 
    popt->midvrule_nl = column->vertical;
    popt->midvrule_wrap = column->vertical;
    popt->midvrule_blank = column->vertical;
 
    /* Same for all unicode today */
    popt->header_nl_left = unicode_style.header_nl_left;
    popt->header_nl_right = unicode_style.header_nl_right;
    popt->nl_left = unicode_style.nl_left;
    popt->nl_right = unicode_style.nl_right;
    popt->wrap_left = unicode_style.wrap_left;
    popt->wrap_right = unicode_style.wrap_right;
    popt->wrap_right_border = unicode_style.wrap_right_border;
}
 
/*
 * Compute the byte distance to the end of the string or *target_width
 * display character positions, whichever comes first.  Update *target_width
 * to be the number of display character positions actually filled.
 */
static int
strlen_max_width(unsigned char *str, int *target_width, int encoding)
{
    unsigned char *start = str;
    unsigned char *end = str + strlen((char *) str);
    int         curr_width = 0;
 
    while (str < end)
    {
        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 (curr_width == 0), we have to
         * accept it.
         */
        if (*target_width < curr_width + char_width && curr_width != 0)
            break;
 
        curr_width += char_width;
 
        str += PQmblen((char *) str, encoding);
 
        if (str > end)          /* Don't overrun invalid string */
            str = end;
    }
 
    *target_width = curr_width;
 
    return str - start;
}