print.c File Reference

#include "postgres_fe.h"
#include <limits.h>
#include <math.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include "catalog/pg_type_d.h"
#include "fe_utils/mbprint.h"
#include "fe_utils/print.h"

Include dependency graph for print.c:

Go to the source code of this file.

Data Structures
struct	unicodeStyleRowFormat
struct	unicodeStyleColumnFormat
struct	unicodeStyleBorderFormat
struct	unicodeStyleFormat

Macros
#define	LONGTABLE_WHITESPACE   " \t\n"

Typedefs
typedef struct unicodeStyleRowFormat	unicodeStyleRowFormat
typedef struct unicodeStyleColumnFormat	unicodeStyleColumnFormat
typedef struct unicodeStyleBorderFormat	unicodeStyleBorderFormat
typedef struct unicodeStyleFormat	unicodeStyleFormat

Functions
static int	strlen_max_width (unsigned char *str, int *target_width, int encoding)
static void	IsPagerNeeded (const printTableContent *cont, int extra_lines, bool expanded, FILE **fout, bool *is_pager)
static void	print_aligned_vertical (const printTableContent *cont, FILE *fout, bool is_pager)
static int	integer_digits (const char *my_str)
static int	additional_numeric_locale_len (const char *my_str)
static char *	format_numeric_locale (const char *my_str)
static void	print_separator (struct separator sep, FILE *fout)
static printTableFooter *	footers_with_default (const printTableContent *cont)
static void	print_unaligned_text (const printTableContent *cont, FILE *fout)
static void	print_unaligned_vertical (const printTableContent *cont, FILE *fout)
static void	_print_horizontal_line (const unsigned int ncolumns, const unsigned int *widths, unsigned short border, printTextRule pos, const printTextFormat *format, FILE *fout)
static void	print_aligned_text (const printTableContent *cont, FILE *fout, bool is_pager)
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)
static void	csv_escaped_print (const char *str, FILE *fout)
static void	csv_print_field (const char *str, FILE *fout, char sep)
static void	print_csv_text (const printTableContent *cont, FILE *fout)
static void	print_csv_vertical (const printTableContent *cont, FILE *fout)
void	html_escaped_print (const char *in, FILE *fout)
static void	print_html_text (const printTableContent *cont, FILE *fout)
static void	print_html_vertical (const printTableContent *cont, FILE *fout)
static void	asciidoc_escaped_print (const char *in, FILE *fout)
static void	print_asciidoc_text (const printTableContent *cont, FILE *fout)
static void	print_asciidoc_vertical (const printTableContent *cont, FILE *fout)
static void	latex_escaped_print (const char *in, FILE *fout)
static void	print_latex_text (const printTableContent *cont, FILE *fout)
static void	print_latex_longtable_text (const printTableContent *cont, FILE *fout)
static void	print_latex_vertical (const printTableContent *cont, FILE *fout)
static void	troff_ms_escaped_print (const char *in, FILE *fout)
static void	print_troff_ms_text (const printTableContent *cont, FILE *fout)
static void	print_troff_ms_vertical (const printTableContent *cont, FILE *fout)
void	disable_sigpipe_trap (void)
void	restore_sigpipe_trap (void)
void	set_sigpipe_trap_state (bool ignore)
FILE *	PageOutput (int lines, const printTableOpt *topt)
void	ClosePager (FILE *pagerpipe)
void	printTableInit (printTableContent *const content, const printTableOpt *opt, const char *title, const int ncolumns, const int nrows)
void	printTableAddHeader (printTableContent *const content, char *header, const bool translate, const char align)
void	printTableAddCell (printTableContent *const content, char *cell, const bool translate, const bool mustfree)
void	printTableAddFooter (printTableContent *const content, const char *footer)
void	printTableSetFooter (printTableContent *const content, const char *footer)
void	printTableCleanup (printTableContent *const content)
void	printTable (const printTableContent *cont, FILE *fout, bool is_pager, FILE *flog)
void	printQuery (const PGresult *result, const printQueryOpt *opt, FILE *fout, bool is_pager, FILE *flog)
char	column_type_alignment (Oid ftype)
void	setDecimalLocale (void)
const printTextFormat *	get_line_style (const printTableOpt *opt)
void	refresh_utf8format (const printTableOpt *opt)

Variables
volatile sig_atomic_t	cancel_pressed = false
static bool	always_ignore_sigpipe = false
static char *	decimal_point
static int	groupdigits
static char *	thousands_sep
static char	default_footer [100]
static printTableFooter	default_footer_cell = {default_footer, NULL}
const printTextFormat	pg_asciiformat
const printTextFormat	pg_asciiformat_old
printTextFormat	pg_utf8format
static const unicodeStyleFormat	unicode_style

Macro Definition Documentation

LONGTABLE_WHITESPACE

#define LONGTABLE_WHITESPACE   " \t\n"

Typedef Documentation

unicodeStyleBorderFormat

typedef struct unicodeStyleBorderFormat unicodeStyleBorderFormat

unicodeStyleColumnFormat

typedef struct unicodeStyleColumnFormat unicodeStyleColumnFormat

unicodeStyleFormat

typedef struct unicodeStyleFormat unicodeStyleFormat

unicodeStyleRowFormat

typedef struct unicodeStyleRowFormat unicodeStyleRowFormat

Function Documentation

_print_horizontal_line()

static void _print_horizontal_line ( const unsigned int  ncolumns, const unsigned int *  widths, unsigned short  border, printTextRule  pos, const printTextFormat *  format, FILE *  fout  )

static

Definition at line 593 of file print.c.

{
    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);
}

References format, fprintf, printTextLineFormat::hrule, i, j, printTextLineFormat::leftvrule, printTextLineFormat::midvrule, and printTextLineFormat::rightvrule.

Referenced by print_aligned_text().

additional_numeric_locale_len()

static int additional_numeric_locale_len ( const char *  my_str )

static

Definition at line 289 of file print.c.

{
    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;
}

References decimal_point, groupdigits, integer_digits(), len, and thousands_sep.

Referenced by format_numeric_locale().

asciidoc_escaped_print()

static void asciidoc_escaped_print ( const char *  in, FILE *  fout  )

static

Definition at line 2168 of file print.c.

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

Referenced by print_asciidoc_text(), and print_asciidoc_vertical().

ClosePager()

void ClosePager

(

FILE *

pagerpipe

)

Definition at line 3141 of file print.c.

{
    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();
    }
}

References _, cancel_pressed, fprintf, restore_sigpipe_trap(), and generate_unaccent_rules::stdout.

Referenced by exec_command_sf_sv(), ExecQueryAndProcessResults(), helpSQL(), helpVariables(), print_aligned_text(), print_aligned_vertical(), printHistory(), printTable(), slashUsage(), and usage().

column_type_alignment()

char column_type_alignment

(

Oid

ftype

)

Definition at line 3614 of file print.c.

{
    char        align;
 
    switch (ftype)
    {
        case INT2OID:
        case INT4OID:
        case INT8OID:
        case FLOAT4OID:
        case FLOAT8OID:
        case NUMERICOID:
        case OIDOID:
        case XIDOID:
        case XID8OID:
        case CIDOID:
        case MONEYOID:
            align = 'r';
            break;
        default:
            align = 'l';
            break;
    }
    return align;
}

Referenced by printCrosstab(), and printQuery().

csv_escaped_print()

static void csv_escaped_print ( const char *  str, FILE *  fout  )

static

Definition at line 1840 of file print.c.

{
    const char *p;
 
    fputc('"', fout);
    for (p = str; *p; p++)
    {
        if (*p == '"')
            fputc('"', fout);   /* double quotes are doubled */
        fputc(*p, fout);
    }
    fputc('"', fout);
}

References str.

Referenced by csv_print_field().

csv_print_field()

static void csv_print_field ( const char *  str, FILE *  fout, char  sep  )

static

Definition at line 1855 of file print.c.

{
    /*----------------
     * 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);
}

References csv_escaped_print(), and str.

Referenced by print_csv_text(), and print_csv_vertical().

disable_sigpipe_trap()

void disable_sigpipe_trap

(

void

)

Definition at line 3039 of file print.c.

{
#ifndef WIN32
    pqsignal(SIGPIPE, SIG_IGN);
#endif
}

References pqsignal, and SIGPIPE.

Referenced by do_copy(), do_watch(), exec_command_write(), PageOutput(), and SetupGOutput().

footers_with_default()

static printTableFooter * footers_with_default ( const printTableContent *  cont )

static

Definition at line 398 of file print.c.

{
    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;
}

References default_footer, printTableOpt::default_footer, default_footer_cell, printTableContent::footers, ngettext, printTableContent::nrows, printTableContent::opt, printTableOpt::prior_records, and snprintf.

Referenced by print_aligned_text(), print_aligned_vertical(), print_asciidoc_text(), print_html_text(), print_latex_text(), print_troff_ms_text(), and print_unaligned_text().

format_numeric_locale()

static char * format_numeric_locale ( const char *  my_str )

static

Definition at line 314 of file print.c.

{
    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(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;
}

References additional_numeric_locale_len(), Assert, decimal_point, groupdigits, i, integer_digits(), pg_malloc(), pg_strdup(), and thousands_sep.

Referenced by printQuery().

get_line_style()

const printTextFormat * get_line_style

(

const printTableOpt *

opt

)

Definition at line 3677 of file print.c.

{
    /*
     * 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;
}

References printTableOpt::line_style, and pg_asciiformat.

Referenced by print_aligned_text(), print_aligned_vertical(), print_aligned_vertical_line(), printPsetInfo(), and pset_value_string().

html_escaped_print()

void html_escaped_print	(	const char *	in,
		FILE *	fout
	)

Definition at line 1952 of file print.c.

{
    const char *p;
    bool        leading_space = true;
 
    for (p = in; *p; p++)
    {
        switch (*p)
        {
            case '&':
                fputs("&", 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;
    }
}

Referenced by print_html_text(), print_html_vertical(), and PrintQueryStatus().

integer_digits()

static int integer_digits ( const char *  my_str )

static

Definition at line 278 of file print.c.

{
    /* ignoring any sign ... */
    if (my_str[0] == '-' || my_str[0] == '+')
        my_str++;
    /* ... count initial integral digits */
    return strspn(my_str, "0123456789");
}

Referenced by additional_numeric_locale_len(), and format_numeric_locale().

IsPagerNeeded()

static void IsPagerNeeded ( const printTableContent *  cont, int  extra_lines, bool  expanded, FILE **  fout, bool *  is_pager  )

static

Definition at line 3403 of file print.c.

{
    if (*fout == stdout)
    {
        int         lines;
 
        if (expanded)
            lines = (cont->ncolumns + 1) * cont->nrows;
        else
            lines = cont->nrows + 1;
 
        if (!cont->opt->tuples_only)
        {
            printTableFooter *f;
 
            /*
             * FIXME -- this is slightly bogus: it counts the number of
             * footers, not the number of lines in them.
             */
            for (f = cont->footers; f; f = f->next)
                lines++;
        }
 
        *fout = PageOutput(lines + extra_lines, cont->opt);
        *is_pager = (*fout != stdout);
    }
    else
        *is_pager = false;
}

References printTableContent::footers, if(), printTableContent::ncolumns, printTableFooter::next, printTableContent::nrows, printTableContent::opt, PageOutput(), generate_unaccent_rules::stdout, and printTableOpt::tuples_only.

Referenced by print_aligned_text(), print_aligned_vertical(), and printTable().

latex_escaped_print()

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

static

Definition at line 2392 of file print.c.

{
    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);
        }
}

Referenced by print_latex_longtable_text(), print_latex_text(), and print_latex_vertical().

PageOutput()

FILE * PageOutput	(	int	lines,
		const printTableOpt *	topt
	)

Definition at line 3089 of file print.c.

{
    /* check whether we need / can / are supposed to use pager */
    if (topt && topt->pager && isatty(fileno(stdin)) && isatty(fileno(stdout)))
    {
#ifdef TIOCGWINSZ
        unsigned short int pager = topt->pager;
        int         min_lines = topt->pager_min_lines;
        int         result;
        struct winsize screen_size;
 
        result = ioctl(fileno(stdout), TIOCGWINSZ, &screen_size);
 
        /* >= accounts for a one-line prompt */
        if (result == -1
            || (lines >= screen_size.ws_row && lines >= min_lines)
            || 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;
}

References DEFAULT_PAGER, disable_sigpipe_trap(), fflush(), printTableOpt::pager, printTableOpt::pager_min_lines, restore_sigpipe_trap(), and generate_unaccent_rules::stdout.

Referenced by exec_command_sf_sv(), ExecQueryAndProcessResults(), helpSQL(), helpVariables(), IsPagerNeeded(), print_aligned_text(), printHistory(), slashUsage(), and usage().

print_aligned_text()

static void print_aligned_text ( const printTableContent *  cont, FILE *  fout, bool  is_pager  )

static

Definition at line 635 of file print.c.

{
    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;
    unsigned int extra_row_output_lines = 0;
    unsigned int extra_output_lines = 0;
 
    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(col_count * sizeof(*width_header));
        width_average = pg_malloc0(col_count * sizeof(*width_average));
        max_width = pg_malloc0(col_count * sizeof(*max_width));
        width_wrap = pg_malloc0(col_count * sizeof(*width_wrap));
        max_nl_lines = pg_malloc0(col_count * sizeof(*max_nl_lines));
        curr_nl_line = pg_malloc0(col_count * sizeof(*curr_nl_line));
        col_lineptrs = pg_malloc0(col_count * sizeof(*col_lineptrs));
        max_bytes = pg_malloc0(col_count * sizeof(*max_bytes));
        format_buf = pg_malloc0(col_count * sizeof(*format_buf));
        header_done = pg_malloc0(col_count * sizeof(*header_done));
        bytes_output = pg_malloc0(col_count * sizeof(*bytes_output));
        wrap = pg_malloc0(col_count * sizeof(*wrap));
    }
    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;
        if (nl_lines > extra_row_output_lines)
            extra_row_output_lines = nl_lines;
 
        width_header[i] = width;
    }
    /* Add height of tallest header column */
    extra_output_lines += extra_row_output_lines;
    extra_row_output_lines = 0;
 
    /* scan all cells, find maximum width, compute cell_count */
    for (i = 0, ptr = cont->cells; *ptr; ptr++, i++, 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 % col_count])
            max_width[i % col_count] = width;
        if (nl_lines > max_nl_lines[i % col_count])
            max_nl_lines[i % col_count] = nl_lines;
        if (bytes_required > max_bytes[i % col_count])
            max_bytes[i % col_count] = bytes_required;
 
        width_average[i % col_count] += width;
    }
 
    /* If we have rows, compute average */
    if (col_count != 0 && cell_count != 0)
    {
        int         rows = cell_count / col_count;
 
        for (i = 0; i < col_count; i++)
            width_average[i] /= 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((max_nl_lines[i] + 1) *
                                     sizeof(**col_lineptrs));
 
        format_buf[i] = pg_malloc(max_bytes[i] + 1);
 
        col_lineptrs[i]->ptr = format_buf[i];
    }
 
    /* Default word wrap to the full width, i.e. no word wrap */
    for (i = 0; i < col_count; i++)
        width_wrap[i] = max_width[i];
 
    /*
     * 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 newlines or our wrapping now need the pager */
    if (!is_pager && fout == stdout)
    {
        /* 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);
 
            /*
             * A row can have both wrapping and newlines that cause it to
             * display across multiple lines.  We check for both cases below.
             */
            if (width > 0 && width_wrap[i])
            {
                unsigned int extra_lines;
 
                /* don't count the first line of nl_lines - it's not "extra" */
                extra_lines = ((width - 1) / width_wrap[i]) + nl_lines - 1;
                if (extra_lines > extra_row_output_lines)
                    extra_row_output_lines = extra_lines;
            }
 
            /* i is the current column number: increment with wrap */
            if (++i >= col_count)
            {
                i = 0;
                /* At last column of each row, add tallest column height */
                extra_output_lines += extra_row_output_lines;
                extra_row_output_lines = 0;
            }
        }
        IsPagerNeeded(cont, extra_output_lines, 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);
}

References _print_horizontal_line(), printTableContent::aligns, printTableOpt::border, cancel_pressed, printTableContent::cells, cleanup(), ClosePager(), printTableOpt::columns, printTableFooter::data, encoding, printTableOpt::encoding, printTableOpt::env_columns, printTableOpt::expanded, footers_with_default(), format, printTableOpt::format, fprintf, free, get_line_style(), printTableContent::headers, i, IsPagerNeeded(), j, printTextLineFormat::leftvrule, printTextLineFormat::midvrule, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, PageOutput(), pg_malloc(), pg_malloc0(), pg_wcsformat(), pg_wcssize(), print_aligned_vertical(), PRINT_LINE_WRAP_NEWLINE, PRINT_LINE_WRAP_NONE, PRINT_LINE_WRAP_WRAP, PRINT_RULE_BOTTOM, PRINT_RULE_DATA, PRINT_RULE_MIDDLE, PRINT_RULE_TOP, PRINT_WRAPPED, lineptr::ptr, printTextLineFormat::rightvrule, printTableOpt::start_table, generate_unaccent_rules::stdout, printTableOpt::stop_table, strlen_max_width(), printTableContent::title, printTableOpt::tuples_only, and lineptr::width.

Referenced by printTable().

print_aligned_vertical()

static void print_aligned_vertical ( const printTableContent *  cont, FILE *  fout, bool  is_pager  )

static

Definition at line 1324 of file print.c.

{
    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;
 
    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, 0, 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((sizeof(*dlineptr)) * (dheight + 1));
    hlineptr = pg_malloc((sizeof(*hlineptr)) * (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
    }
 
    /*
     * Calculate available width for data in wrapped mode
     */
    if (cont->opt->format == PRINT_WRAPPED)
    {
        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 (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);
}

References printTableOpt::border, cancel_pressed, printTableContent::cells, ClosePager(), printTableOpt::columns, printTableFooter::data, encoding, printTableOpt::encoding, printTableOpt::env_columns, printTableContent::footers, footers_with_default(), format, printTableOpt::format, fprintf, free, get_line_style(), printTableContent::headers, i, IsPagerNeeded(), printTextLineFormat::leftvrule, printTextLineFormat::midvrule, printTableContent::ncolumns, printTableFooter::next, printTableContent::nrows, printTableContent::opt, pg_asciiformat_old, pg_malloc(), pg_wcsformat(), pg_wcssize(), print_aligned_vertical_line(), PRINT_RULE_BOTTOM, PRINT_RULE_DATA, PRINT_RULE_MIDDLE, PRINT_RULE_TOP, PRINT_WRAPPED, printTableOpt::prior_records, lineptr::ptr, printTextLineFormat::rightvrule, printTableOpt::start_table, generate_unaccent_rules::stdout, printTableOpt::stop_table, strlen_max_width(), printTableContent::title, printTableOpt::tuples_only, and lineptr::width.

Referenced by print_aligned_text(), and printTable().

print_aligned_vertical_line()

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  )

static

Definition at line 1225 of file print.c.

{
    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);
}

References printTableOpt::border, printTableOpt::expanded_header_exact_width, printTableOpt::expanded_header_width_type, fprintf, get_line_style(), printTextLineFormat::hrule, i, printTextLineFormat::leftvrule, printTextFormat::lrule, Max, printTextLineFormat::midvrule, Min, PRINT_XHEADER_COLUMN, PRINT_XHEADER_EXACT_WIDTH, PRINT_XHEADER_PAGE, and printTextLineFormat::rightvrule.

Referenced by print_aligned_vertical().

print_asciidoc_text()

static void print_asciidoc_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2186 of file print.c.

{
    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);
        }
    }
}

References printTableContent::aligns, asciidoc_escaped_print(), printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, footers_with_default(), fprintf, printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_asciidoc_vertical()

static void print_asciidoc_vertical ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2296 of file print.c.

{
    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);
        }
    }
}

References printTableContent::aligns, asciidoc_escaped_print(), printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, printTableContent::footers, fprintf, printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::prior_records, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_csv_text()

static void print_csv_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 1880 of file print.c.

{
    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);
    }
}

References cancel_pressed, printTableContent::cells, csv_print_field(), printTableOpt::csvFieldSep, printTableContent::headers, i, printTableContent::ncolumns, printTableContent::opt, printTableOpt::start_table, and printTableOpt::tuples_only.

Referenced by printTable().

print_csv_vertical()

static void print_csv_vertical ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 1920 of file print.c.

{
    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);
    }
}

References cancel_pressed, printTableContent::cells, csv_print_field(), printTableOpt::csvFieldSep, printTableContent::headers, i, printTableContent::ncolumns, and printTableContent::opt.

Referenced by printTable().

print_html_text()

static void print_html_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 1993 of file print.c.

{
    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);
    }
}

References printTableContent::aligns, printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, footers_with_default(), fprintf, printTableContent::headers, html_escaped_print(), i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::start_table, printTableOpt::stop_table, printTableOpt::tableAttr, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_html_vertical()

static void print_html_vertical ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2082 of file print.c.

{
    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);
    }
}

References printTableContent::aligns, printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, printTableContent::footers, fprintf, printTableContent::headers, html_escaped_print(), i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::prior_records, printTableOpt::start_table, printTableOpt::stop_table, printTableOpt::tableAttr, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_latex_longtable_text()

static void print_latex_longtable_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2561 of file print.c.

{
    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);
}

References printTableContent::aligns, printTableOpt::border, cancel_pressed, printTableContent::cells, printTableContent::headers, i, latex_escaped_print(), LONGTABLE_WHITESPACE, printTableContent::ncolumns, printTableContent::opt, printTableOpt::start_table, printTableOpt::stop_table, printTableOpt::tableAttr, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_latex_text()

static void print_latex_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2454 of file print.c.

{
    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);
    }
}

References printTableContent::aligns, printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, footers_with_default(), printTableContent::headers, i, latex_escaped_print(), printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_latex_vertical()

static void print_latex_vertical ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2717 of file print.c.

{
    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);
    }
}

References printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, printTableContent::footers, fprintf, printTableContent::headers, i, latex_escaped_print(), printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::prior_records, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_separator()

static void print_separator ( struct separator  sep, FILE *  fout  )

static

Definition at line 379 of file print.c.

{
    if (sep.separator_zero)
        fputc('\000', fout);
    else if (sep.separator)
        fputs(sep.separator, fout);
}

References separator::separator, and separator::separator_zero.

Referenced by print_unaligned_text(), and print_unaligned_vertical().

print_troff_ms_text()

static void print_troff_ms_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2827 of file print.c.

{
    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);
    }
}

References printTableContent::aligns, printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, footers_with_default(), printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, troff_ms_escaped_print(), and printTableOpt::tuples_only.

Referenced by printTable().

print_troff_ms_vertical()

static void print_troff_ms_vertical ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 2919 of file print.c.

{
    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);
    }
}

References printTableOpt::border, cancel_pressed, printTableContent::cells, printTableFooter::data, printTableContent::footers, fprintf, printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, printTableOpt::prior_records, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, troff_ms_escaped_print(), and printTableOpt::tuples_only.

Referenced by printTable().

print_unaligned_text()

static void print_unaligned_text ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 422 of file print.c.

{
    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);
        }
    }
}

References cancel_pressed, printTableContent::cells, printTableFooter::data, printTableOpt::fieldSep, footers_with_default(), printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, print_separator(), printTableOpt::recordSep, separator::separator_zero, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

print_unaligned_vertical()

static void print_unaligned_vertical ( const printTableContent *  cont, FILE *  fout  )

static

Definition at line 513 of file print.c.

{
    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);
        }
    }
}

References cancel_pressed, printTableContent::cells, printTableFooter::data, printTableOpt::fieldSep, printTableContent::footers, printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::opt, print_separator(), printTableOpt::recordSep, separator::separator_zero, printTableOpt::start_table, printTableOpt::stop_table, printTableContent::title, and printTableOpt::tuples_only.

Referenced by printTable().

printQuery()

void printQuery	(	const PGresult *	result,
		const printQueryOpt *	opt,
		FILE *	fout,
		bool	is_pager,
		FILE *	flog
	)

Definition at line 3549 of file print.c.

{
    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
            {
                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);
}

References printTableContent::aligns, Assert, cancel_pressed, column_type_alignment(), printQueryOpt::footers, format_numeric_locale(), i, printQueryOpt::n_translate_columns, printTableContent::ncolumns, printTableContent::nrows, printQueryOpt::nullPrint, printTableOpt::numericLocale, PQfname(), PQftype(), PQgetisnull(), PQgetvalue(), PQnfields(), PQntuples(), printTable(), printTableAddCell(), printTableAddFooter(), printTableAddHeader(), printTableCleanup(), printTableInit(), printQueryOpt::title, printQueryOpt::topt, translate(), printQueryOpt::translate_columns, and printQueryOpt::translate_header.

Referenced by describeAccessMethods(), describeAggregates(), describeConfigurationParameters(), describeFunctions(), describeOneTableDetails(), describeOneTSConfig(), describeOneTSParser(), describeOperators(), describeRoleGrants(), describeSubscriptions(), describeTablespaces(), describeTypes(), ExecQueryAndProcessResults(), listAllDbs(), listCasts(), listCollations(), listConversions(), listDbRoleSettings(), listDefaultACLs(), listDomains(), listEventTriggers(), listExtendedStats(), listExtensions(), listForeignDataWrappers(), listForeignServers(), listForeignTables(), listLanguages(), listLargeObjects(), listOneExtensionContents(), listOperatorClasses(), listOperatorFamilies(), listOpFamilyFunctions(), listOpFamilyOperators(), listPartitionedTables(), listPublications(), listSchemas(), listTables(), listTSConfigs(), listTSDictionaries(), listTSParsers(), listTSTemplates(), listUserMappings(), objectDescription(), permissionsList(), and PrintQueryTuples().

printTable()

void printTable	(	const printTableContent *	cont,
		FILE *	fout,
		bool	is_pager,
		FILE *	flog
	)

Definition at line 3443 of file print.c.

{
    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, 0, (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 */
 
    if (flog)
        print_aligned_text(cont, flog, false);
 
    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);
}

References _, cancel_pressed, ClosePager(), exit(), EXIT_FAILURE, printTableOpt::expanded, printTableOpt::format, fprintf, IsPagerNeeded(), printTableContent::opt, PRINT_ALIGNED, print_aligned_text(), print_aligned_vertical(), PRINT_ASCIIDOC, print_asciidoc_text(), print_asciidoc_vertical(), PRINT_CSV, print_csv_text(), print_csv_vertical(), PRINT_HTML, print_html_text(), print_html_vertical(), PRINT_LATEX, PRINT_LATEX_LONGTABLE, print_latex_longtable_text(), print_latex_text(), print_latex_vertical(), PRINT_NOTHING, PRINT_TROFF_MS, print_troff_ms_text(), print_troff_ms_vertical(), PRINT_UNALIGNED, print_unaligned_text(), print_unaligned_vertical(), and PRINT_WRAPPED.

Referenced by describeOneTableDetails(), describePublications(), describeRoles(), printCrosstab(), and printQuery().

printTableAddCell()

void printTableAddCell	(	printTableContent *const	content,
		char *	cell,
		const bool	translate,
		const bool	mustfree
	)

Definition at line 3260 of file print.c.

{
    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 %lld exceeded.\n"),
                (long long int) 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((total_cells + 1) * sizeof(bool));
 
        content->cellmustfree[content->cellsadded] = true;
    }
    content->cell++;
    content->cellsadded++;
}

References _, printTableContent::cell, printTableContent::cellmustfree, printTableContent::cellsadded, printTableOpt::encoding, exit(), EXIT_FAILURE, fprintf, if(), mbvalidate(), printTableContent::ncolumns, printTableContent::nrows, printTableContent::opt, pg_malloc0(), and translate().

Referenced by describeOneTableDetails(), describePublications(), describeRoles(), and printQuery().

printTableAddFooter()

void printTableAddFooter	(	printTableContent *const	content,
		const char *	footer
	)

Definition at line 3310 of file print.c.

{
    printTableFooter *f;
 
    f = pg_malloc0(sizeof(*f));
    f->data = pg_strdup(footer);
 
    if (content->footers == NULL)
        content->footers = f;
    else
        content->footer->next = f;
 
    content->footer = f;
}

References printTableFooter::data, printTableContent::footer, printTableContent::footers, printTableFooter::next, pg_malloc0(), and pg_strdup().

Referenced by add_tablespace_footer(), addFooterToPublicationDesc(), describeOneTableDetails(), printQuery(), and printTableSetFooter().

printTableAddHeader()

void printTableAddHeader	(	printTableContent *const	content,
		char *	header,
		const bool	translate,
		const char	align
	)

Definition at line 3220 of file print.c.

{
#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++;
}

References _, printTableContent::align, printTableOpt::encoding, exit(), EXIT_FAILURE, fprintf, printTableContent::header, printTableContent::headers, mbvalidate(), printTableContent::ncolumns, printTableContent::opt, and translate().

Referenced by describeOneTableDetails(), describePublications(), describeRoles(), printCrosstab(), and printQuery().

printTableCleanup()

void printTableCleanup

(

printTableContent *const

content

)

Definition at line 3353 of file print.c.

{
    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;
}

References printTableContent::align, printTableContent::aligns, printTableContent::cell, printTableContent::cellmustfree, printTableContent::cells, printTableFooter::data, printTableContent::footer, printTableContent::footers, for(), free, printTableContent::header, printTableContent::headers, i, printTableContent::ncolumns, printTableFooter::next, printTableContent::nrows, printTableContent::opt, printTableContent::title, and unconstify.

Referenced by describeOneTableDetails(), describePublications(), describeRoles(), printCrosstab(), and printQuery().

printTableInit()

void printTableInit	(	printTableContent *const	content,
		const printTableOpt *	opt,
		const char *	title,
		const int	ncolumns,
		const int	nrows
	)

Definition at line 3172 of file print.c.

{
    uint64      total_cells;
 
    content->opt = opt;
    content->title = title;
    content->ncolumns = ncolumns;
    content->nrows = nrows;
 
    content->headers = pg_malloc0((ncolumns + 1) * sizeof(*content->headers));
 
    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 %lld is equal to or exceeds maximum %lld.\n"),
                (long long int) total_cells,
                (long long int) (SIZE_MAX / sizeof(*content->cells)));
        exit(EXIT_FAILURE);
    }
    content->cells = pg_malloc0((total_cells + 1) * sizeof(*content->cells));
 
    content->cellmustfree = NULL;
    content->footers = NULL;
 
    content->aligns = pg_malloc0((ncolumns + 1) * sizeof(*content->align));
 
    content->header = content->headers;
    content->cell = content->cells;
    content->footer = content->footers;
    content->align = content->aligns;
    content->cellsadded = 0;
}

References _, printTableContent::align, printTableContent::aligns, printTableContent::cell, printTableContent::cellmustfree, printTableContent::cells, printTableContent::cellsadded, exit(), EXIT_FAILURE, printTableContent::footer, printTableContent::footers, fprintf, printTableContent::header, printTableContent::headers, printTableContent::ncolumns, printTableContent::nrows, printTableContent::opt, pg_malloc0(), and printTableContent::title.

Referenced by describeOneTableDetails(), describePublications(), describeRoles(), printCrosstab(), and printQuery().

printTableSetFooter()

void printTableSetFooter	(	printTableContent *const	content,
		const char *	footer
	)

Definition at line 3335 of file print.c.

{
    if (content->footers != NULL)
    {
        free(content->footer->data);
        content->footer->data = pg_strdup(footer);
    }
    else
        printTableAddFooter(content, footer);
}

References printTableFooter::data, printTableContent::footer, printTableContent::footers, free, pg_strdup(), and printTableAddFooter().

Referenced by add_tablespace_footer().

refresh_utf8format()

void refresh_utf8format

(

const printTableOpt *

opt

)

Definition at line 3691 of file print.c.

{
    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;
}

References unicodeStyleFormat::border_style, unicodeStyleFormat::column_style, unicodeStyleColumnFormat::down_and_horizontal, unicodeStyleBorderFormat::down_and_left, unicodeStyleBorderFormat::down_and_right, unicodeStyleFormat::header_nl_left, printTextFormat::header_nl_left, unicodeStyleFormat::header_nl_right, printTextFormat::header_nl_right, unicodeStyleRowFormat::horizontal, unicodeStyleBorderFormat::horizontal, printTextLineFormat::hrule, unicodeStyleBorderFormat::left_and_right, printTextLineFormat::leftvrule, printTextFormat::lrule, printTextLineFormat::midvrule, printTextFormat::midvrule_blank, printTextFormat::midvrule_nl, printTextFormat::midvrule_wrap, printTextFormat::name, unicodeStyleFormat::nl_left, printTextFormat::nl_left, unicodeStyleFormat::nl_right, printTextFormat::nl_right, pg_utf8format, PRINT_RULE_BOTTOM, PRINT_RULE_DATA, PRINT_RULE_MIDDLE, PRINT_RULE_TOP, printTextLineFormat::rightvrule, unicodeStyleFormat::row_style, printTableOpt::unicode_border_linestyle, printTableOpt::unicode_column_linestyle, printTableOpt::unicode_header_linestyle, unicode_style, unicodeStyleColumnFormat::up_and_horizontal, unicodeStyleBorderFormat::up_and_right, unicodeStyleColumnFormat::vertical, unicodeStyleBorderFormat::vertical, unicodeStyleColumnFormat::vertical_and_horizontal, unicodeStyleRowFormat::vertical_and_left, unicodeStyleRowFormat::vertical_and_right, unicodeStyleFormat::wrap_left, printTextFormat::wrap_left, unicodeStyleFormat::wrap_right, printTextFormat::wrap_right, unicodeStyleFormat::wrap_right_border, and printTextFormat::wrap_right_border.

Referenced by do_pset(), and main().

restore_sigpipe_trap()

void restore_sigpipe_trap

(

void

)

Definition at line 3062 of file print.c.

{
#ifndef WIN32
    pqsignal(SIGPIPE, always_ignore_sigpipe ? SIG_IGN : SIG_DFL);
#endif
}

References always_ignore_sigpipe, pqsignal, and SIGPIPE.

Referenced by CloseGOutput(), ClosePager(), do_copy(), do_watch(), exec_command_write(), PageOutput(), and setQFout().

set_sigpipe_trap_state()

void set_sigpipe_trap_state

(

bool

ignore

)

Definition at line 3075 of file print.c.

{
    always_ignore_sigpipe = ignore;
}

References always_ignore_sigpipe.

Referenced by setQFout().

setDecimalLocale()

void setDecimalLocale

(

void

)

Definition at line 3641 of file print.c.

{
    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 = ".";
}

References decimal_point, groupdigits, pg_strdup(), and thousands_sep.

Referenced by main().

strlen_max_width()

static int strlen_max_width ( unsigned char *  str, int *  target_width, int  encoding  )

static

Definition at line 3746 of file print.c.

{
    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;
}

References encoding, PQdsplen(), PQmblen(), start, and str.

Referenced by print_aligned_text(), and print_aligned_vertical().

troff_ms_escaped_print()

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

static

Definition at line 2810 of file print.c.

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

Referenced by print_troff_ms_text(), and print_troff_ms_vertical().

Variable Documentation

always_ignore_sigpipe

bool always_ignore_sigpipe = false

static

Definition at line 45 of file print.c.

Referenced by restore_sigpipe_trap(), and set_sigpipe_trap_state().

cancel_pressed

volatile sig_atomic_t cancel_pressed = false

Definition at line 43 of file print.c.

Referenced by ClosePager(), describeTableDetails(), do_watch(), ExecQueryAndProcessResults(), ExecQueryTuples(), listExtensionContents(), listTSConfigsVerbose(), listTSParsersVerbose(), MainLoop(), print_aligned_text(), print_aligned_vertical(), print_asciidoc_text(), print_asciidoc_vertical(), print_csv_text(), print_csv_vertical(), print_html_text(), print_html_vertical(), print_latex_longtable_text(), print_latex_text(), print_latex_vertical(), print_troff_ms_text(), print_troff_ms_vertical(), print_unaligned_text(), print_unaligned_vertical(), printQuery(), printTable(), PrintVariables(), psql_cancel_callback(), SendQuery(), and wait_until_connected().

decimal_point

char* decimal_point

static

Definition at line 48 of file print.c.

Referenced by additional_numeric_locale_len(), format_numeric_locale(), and setDecimalLocale().

default_footer

char default_footer[100]

static

Definition at line 52 of file print.c.

Referenced by footers_with_default().

default_footer_cell

printTableFooter default_footer_cell = {default_footer, NULL}

static

Definition at line 53 of file print.c.

Referenced by footers_with_default().

groupdigits

int groupdigits

static

Definition at line 49 of file print.c.

Referenced by additional_numeric_locale_len(), format_numeric_locale(), and setDecimalLocale().

pg_asciiformat

const printTextFormat pg_asciiformat

Initial value:

=
{
    "ascii",
    {
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"", "|", "|", "|"}
    },
    "|",
    "|",
    "|",
    " ",
    "+",
    " ",
    "+",
    ".",
    ".",
    true
}

Definition at line 56 of file print.c.

Referenced by do_pset(), and get_line_style().

pg_asciiformat_old

const printTextFormat pg_asciiformat_old

Initial value:

=
{
    "old-ascii",
    {
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"-", "+", "+", "+"},
        {"", "|", "|", "|"}
    },
    ":",
    ";",
    " ",
    "+",
    " ",
    " ",
    " ",
    " ",
    " ",
    false
}

Definition at line 77 of file print.c.

Referenced by do_pset(), and print_aligned_vertical().

pg_utf8format

printTextFormat pg_utf8format

Definition at line 99 of file print.c.

Referenced by do_pset(), and refresh_utf8format().

thousands_sep

char* thousands_sep

static

Definition at line 50 of file print.c.

Referenced by additional_numeric_locale_len(), format_numeric_locale(), and setDecimalLocale().

unicode_style

const unicodeStyleFormat unicode_style

static

Definition at line 140 of file print.c.

Referenced by refresh_utf8format().