diff options
Diffstat (limited to 'src/fe_utils/print.c')
| -rw-r--r-- | src/fe_utils/print.c | 3717 |
1 files changed, 3717 insertions, 0 deletions
diff --git a/src/fe_utils/print.c b/src/fe_utils/print.c new file mode 100644 index 0000000..fe676a9 --- /dev/null +++ b/src/fe_utils/print.c @@ -0,0 +1,3717 @@ +/*------------------------------------------------------------------------- + * + * Query-result printing support for frontend code + * + * This file used to be part of psql, but now it's separated out to allow + * other frontend programs to use it. Because the printing code needs + * access to the cancel_pressed flag as well as SIGPIPE trapping and + * pager open/close functions, all that stuff came with it. + * + * + * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/fe_utils/print.c + * + *------------------------------------------------------------------------- + */ +#include "postgres_fe.h" + +#include <limits.h> +#include <math.h> +#include <unistd.h> + +#ifndef WIN32 +#include <sys/ioctl.h> /* for ioctl() */ +#endif + +#ifdef HAVE_TERMIOS_H +#include <termios.h> +#endif + +#include "catalog/pg_type_d.h" +#include "fe_utils/mbprint.h" +#include "fe_utils/print.h" + +/* + * If the calling program doesn't have any mechanism for setting + * cancel_pressed, it will have no effect. + * + * Note: print.c's general strategy for when to check cancel_pressed is to do + * so at completion of each row of output. + */ +volatile sig_atomic_t cancel_pressed = false; + +static bool always_ignore_sigpipe = false; + +/* info for locale-aware numeric formatting; set up by setDecimalLocale() */ +static char *decimal_point; +static int groupdigits; +static char *thousands_sep; + +static char default_footer[100]; +static printTableFooter default_footer_cell = {default_footer, NULL}; + +/* Line style control structures */ +const printTextFormat pg_asciiformat = +{ + "ascii", + { + {"-", "+", "+", "+"}, + {"-", "+", "+", "+"}, + {"-", "+", "+", "+"}, + {"", "|", "|", "|"} + }, + "|", + "|", + "|", + " ", + "+", + " ", + "+", + ".", + ".", + true +}; + +const printTextFormat pg_asciiformat_old = +{ + "old-ascii", + { + {"-", "+", "+", "+"}, + {"-", "+", "+", "+"}, + {"-", "+", "+", "+"}, + {"", "|", "|", "|"} + }, + ":", + ";", + " ", + "+", + " ", + " ", + " ", + " ", + " ", + false +}; + +/* Default unicode linestyle format */ +printTextFormat pg_utf8format; + +typedef struct unicodeStyleRowFormat +{ + const char *horizontal; + const char *vertical_and_right[2]; + const char *vertical_and_left[2]; +} unicodeStyleRowFormat; + +typedef struct unicodeStyleColumnFormat +{ + const char *vertical; + const char *vertical_and_horizontal[2]; + const char *up_and_horizontal[2]; + const char *down_and_horizontal[2]; +} unicodeStyleColumnFormat; + +typedef struct unicodeStyleBorderFormat +{ + const char *up_and_right; + const char *vertical; + const char *down_and_right; + const char *horizontal; + const char *down_and_left; + const char *left_and_right; +} unicodeStyleBorderFormat; + +typedef struct unicodeStyleFormat +{ + unicodeStyleRowFormat row_style[2]; + unicodeStyleColumnFormat column_style[2]; + unicodeStyleBorderFormat border_style[2]; + const char *header_nl_left; + const char *header_nl_right; + const char *nl_left; + const char *nl_right; + const char *wrap_left; + const char *wrap_right; + bool wrap_right_border; +} unicodeStyleFormat; + +static const unicodeStyleFormat unicode_style = { + { + { + /* U+2500 Box Drawings Light Horizontal */ + "\342\224\200", + + /*-- + * U+251C Box Drawings Light Vertical and Right, + * U+255F Box Drawings Vertical Double and Right Single + *-- + */ + {"\342\224\234", "\342\225\237"}, + + /*-- + * U+2524 Box Drawings Light Vertical and Left, + * U+2562 Box Drawings Vertical Double and Left Single + *-- + */ + {"\342\224\244", "\342\225\242"}, + }, + { + /* U+2550 Box Drawings Double Horizontal */ + "\342\225\220", + + /*-- + * U+255E Box Drawings Vertical Single and Right Double, + * U+2560 Box Drawings Double Vertical and Right + *-- + */ + {"\342\225\236", "\342\225\240"}, + + /*-- + * U+2561 Box Drawings Vertical Single and Left Double, + * U+2563 Box Drawings Double Vertical and Left + *-- + */ + {"\342\225\241", "\342\225\243"}, + }, + }, + { + { + /* U+2502 Box Drawings Light Vertical */ + "\342\224\202", + + /*-- + * U+253C Box Drawings Light Vertical and Horizontal, + * U+256A Box Drawings Vertical Single and Horizontal Double + *-- + */ + {"\342\224\274", "\342\225\252"}, + + /*-- + * U+2534 Box Drawings Light Up and Horizontal, + * U+2567 Box Drawings Up Single and Horizontal Double + *-- + */ + {"\342\224\264", "\342\225\247"}, + + /*-- + * U+252C Box Drawings Light Down and Horizontal, + * U+2564 Box Drawings Down Single and Horizontal Double + *-- + */ + {"\342\224\254", "\342\225\244"}, + }, + { + /* U+2551 Box Drawings Double Vertical */ + "\342\225\221", + + /*-- + * U+256B Box Drawings Vertical Double and Horizontal Single, + * U+256C Box Drawings Double Vertical and Horizontal + *-- + */ + {"\342\225\253", "\342\225\254"}, + + /*-- + * U+2568 Box Drawings Up Double and Horizontal Single, + * U+2569 Box Drawings Double Up and Horizontal + *-- + */ + {"\342\225\250", "\342\225\251"}, + + /*-- + * U+2565 Box Drawings Down Double and Horizontal Single, + * U+2566 Box Drawings Double Down and Horizontal + *-- + */ + {"\342\225\245", "\342\225\246"}, + }, + }, + { + /*-- + * U+2514 Box Drawings Light Up and Right, + * U+2502 Box Drawings Light Vertical, + * U+250C Box Drawings Light Down and Right, + * U+2500 Box Drawings Light Horizontal, + * U+2510 Box Drawings Light Down and Left, + * U+2518 Box Drawings Light Up and Left + *-- + */ + {"\342\224\224", "\342\224\202", "\342\224\214", "\342\224\200", "\342\224\220", "\342\224\230"}, + + /*-- + * U+255A Box Drawings Double Up and Right, + * U+2551 Box Drawings Double Vertical, + * U+2554 Box Drawings Double Down and Right, + * U+2550 Box Drawings Double Horizontal, + * U+2557 Box Drawings Double Down and Left, + * U+255D Box Drawings Double Up and Left + *-- + */ + {"\342\225\232", "\342\225\221", "\342\225\224", "\342\225\220", "\342\225\227", "\342\225\235"}, + }, + " ", + /* U+21B5 Downwards Arrow with Corner Leftwards */ + "\342\206\265", + " ", + /* U+21B5 Downwards Arrow with Corner Leftwards */ + "\342\206\265", + /* U+2026 Horizontal Ellipsis */ + "\342\200\246", + "\342\200\246", + true +}; + + +/* Local functions */ +static int strlen_max_width(unsigned char *str, int *target_width, int encoding); +static 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); + + +/* Count number of digits in integral part of number */ +static int +integer_digits(const char *my_str) +{ + /* ignoring any sign ... */ + if (my_str[0] == '-' || my_str[0] == '+') + my_str++; + /* ... count initial integral digits */ + return strspn(my_str, "0123456789"); +} + +/* Compute additional length required for locale-aware numeric output */ +static int +additional_numeric_locale_len(const char *my_str) +{ + int int_len = integer_digits(my_str), + len = 0; + + /* Account for added thousands_sep instances */ + if (int_len > groupdigits) + len += ((int_len - 1) / groupdigits) * strlen(thousands_sep); + + /* Account for possible additional length of decimal_point */ + if (strchr(my_str, '.') != NULL) + len += strlen(decimal_point) - 1; + + return len; +} + +/* + * Format a numeric value per current LC_NUMERIC locale setting + * + * Returns the appropriately formatted string in a new allocated block, + * caller must free. + * + * setDecimalLocale() must have been called earlier. + */ +static char * +format_numeric_locale(const char *my_str) +{ + char *new_str; + int new_len, + int_len, + leading_digits, + i, + new_str_pos; + + /* + * If the string doesn't look like a number, return it unchanged. This + * check is essential to avoid mangling already-localized "money" values. + */ + if (strspn(my_str, "0123456789+-.eE") != strlen(my_str)) + return pg_strdup(my_str); + + new_len = strlen(my_str) + additional_numeric_locale_len(my_str); + new_str = pg_malloc(new_len + 1); + new_str_pos = 0; + int_len = integer_digits(my_str); + + /* number of digits in first thousands group */ + leading_digits = int_len % groupdigits; + if (leading_digits == 0) + leading_digits = groupdigits; + + /* process sign */ + if (my_str[0] == '-' || my_str[0] == '+') + { + new_str[new_str_pos++] = my_str[0]; + my_str++; + } + + /* process integer part of number */ + for (i = 0; i < int_len; i++) + { + /* Time to insert separator? */ + if (i > 0 && --leading_digits == 0) + { + strcpy(&new_str[new_str_pos], thousands_sep); + new_str_pos += strlen(thousands_sep); + leading_digits = groupdigits; + } + new_str[new_str_pos++] = my_str[i]; + } + + /* handle decimal point if any */ + if (my_str[i] == '.') + { + strcpy(&new_str[new_str_pos], decimal_point); + new_str_pos += strlen(decimal_point); + i++; + } + + /* copy the rest (fractional digits and/or exponent, and \0 terminator) */ + strcpy(&new_str[new_str_pos], &my_str[i]); + + /* assert we didn't underestimate new_len (an overestimate is OK) */ + Assert(strlen(new_str) <= new_len); + + return new_str; +} + + +static void +print_separator(struct separator sep, FILE *fout) +{ + if (sep.separator_zero) + fputc('\000', fout); + else if (sep.separator) + fputs(sep.separator, fout); +} + + +/* + * Return the list of explicitly-requested footers or, when applicable, the + * default "(xx rows)" footer. Always omit the default footer when given + * non-default footers, "\pset footer off", or a specific instruction to that + * effect from a calling backslash command. Vertical formats number each row, + * making the default footer redundant; they do not call this function. + * + * The return value may point to static storage; do not keep it across calls. + */ +static printTableFooter * +footers_with_default(const printTableContent *cont) +{ + if (cont->footers == NULL && cont->opt->default_footer) + { + unsigned long total_records; + + total_records = cont->opt->prior_records + cont->nrows; + snprintf(default_footer, sizeof(default_footer), + ngettext("(%lu row)", "(%lu rows)", total_records), + total_records); + + return &default_footer_cell; + } + else + return cont->footers; +} + + +/*************************/ +/* Unaligned text */ +/*************************/ + + +static void +print_unaligned_text(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned int i; + const char *const *ptr; + bool need_recordsep = false; + + if (cancel_pressed) + return; + + if (cont->opt->start_table) + { + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(cont->title, fout); + print_separator(cont->opt->recordSep, fout); + } + + /* print headers */ + if (!opt_tuples_only) + { + for (ptr = cont->headers; *ptr; ptr++) + { + if (ptr != cont->headers) + print_separator(cont->opt->fieldSep, fout); + fputs(*ptr, fout); + } + need_recordsep = true; + } + } + else + /* assume continuing printout */ + need_recordsep = true; + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (need_recordsep) + { + print_separator(cont->opt->recordSep, fout); + need_recordsep = false; + if (cancel_pressed) + break; + } + fputs(*ptr, fout); + + if ((i + 1) % cont->ncolumns) + print_separator(cont->opt->fieldSep, fout); + else + need_recordsep = true; + } + + /* print footers */ + if (cont->opt->stop_table) + { + printTableFooter *footers = footers_with_default(cont); + + if (!opt_tuples_only && footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + for (f = footers; f; f = f->next) + { + if (need_recordsep) + { + print_separator(cont->opt->recordSep, fout); + need_recordsep = false; + } + fputs(f->data, fout); + need_recordsep = true; + } + } + + /* + * The last record is terminated by a newline, independent of the set + * record separator. But when the record separator is a zero byte, we + * use that (compatible with find -print0 and xargs). + */ + if (need_recordsep) + { + if (cont->opt->recordSep.separator_zero) + print_separator(cont->opt->recordSep, fout); + else + fputc('\n', fout); + } + } +} + + +static void +print_unaligned_vertical(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned int i; + const char *const *ptr; + bool need_recordsep = false; + + if (cancel_pressed) + return; + + if (cont->opt->start_table) + { + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(cont->title, fout); + need_recordsep = true; + } + } + else + /* assume continuing printout */ + need_recordsep = true; + + /* print records */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (need_recordsep) + { + /* record separator is 2 occurrences of recordsep in this mode */ + print_separator(cont->opt->recordSep, fout); + print_separator(cont->opt->recordSep, fout); + need_recordsep = false; + if (cancel_pressed) + break; + } + + fputs(cont->headers[i % cont->ncolumns], fout); + print_separator(cont->opt->fieldSep, fout); + fputs(*ptr, fout); + + if ((i + 1) % cont->ncolumns) + print_separator(cont->opt->recordSep, fout); + else + need_recordsep = true; + } + + if (cont->opt->stop_table) + { + /* print footers */ + if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + print_separator(cont->opt->recordSep, fout); + for (f = cont->footers; f; f = f->next) + { + print_separator(cont->opt->recordSep, fout); + fputs(f->data, fout); + } + } + + /* see above in print_unaligned_text() */ + if (need_recordsep) + { + if (cont->opt->recordSep.separator_zero) + print_separator(cont->opt->recordSep, fout); + else + fputc('\n', fout); + } + } +} + + +/********************/ +/* Aligned text */ +/********************/ + + +/* draw "line" */ +static void +_print_horizontal_line(const unsigned int ncolumns, const unsigned int *widths, + unsigned short border, printTextRule pos, + const printTextFormat *format, + FILE *fout) +{ + const printTextLineFormat *lformat = &format->lrule[pos]; + unsigned int i, + j; + + if (border == 1) + fputs(lformat->hrule, fout); + else if (border == 2) + fprintf(fout, "%s%s", lformat->leftvrule, lformat->hrule); + + for (i = 0; i < ncolumns; i++) + { + for (j = 0; j < widths[i]; j++) + fputs(lformat->hrule, fout); + + if (i < ncolumns - 1) + { + if (border == 0) + fputc(' ', fout); + else + fprintf(fout, "%s%s%s", lformat->hrule, + lformat->midvrule, lformat->hrule); + } + } + + if (border == 2) + fprintf(fout, "%s%s", lformat->hrule, lformat->rightvrule); + else if (border == 1) + fputs(lformat->hrule, fout); + + fputc('\n', fout); +} + + +/* + * Print pretty boxes around cells. + */ +static void +print_aligned_text(const printTableContent *cont, FILE *fout, bool is_pager) +{ + bool opt_tuples_only = cont->opt->tuples_only; + int encoding = cont->opt->encoding; + unsigned short opt_border = cont->opt->border; + const printTextFormat *format = get_line_style(cont->opt); + const printTextLineFormat *dformat = &format->lrule[PRINT_RULE_DATA]; + + unsigned int col_count = 0, + cell_count = 0; + + unsigned int i, + j; + + unsigned int *width_header, + *max_width, + *width_wrap, + *width_average; + unsigned int *max_nl_lines, /* value split by newlines */ + *curr_nl_line, + *max_bytes; + unsigned char **format_buf; + unsigned int width_total; + unsigned int total_header_width; + 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); +} + + +static void +print_aligned_vertical_line(const printTextFormat *format, + const unsigned short opt_border, + unsigned long record, + unsigned int hwidth, + unsigned int dwidth, + printTextRule pos, + FILE *fout) +{ + const printTextLineFormat *lformat = &format->lrule[pos]; + 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) + fputs(lformat->midvrule, fout); + if (reclen-- <= 0) + fputs(lformat->hrule, fout); + } + else + { + if (reclen-- <= 0) + fputc(' ', fout); + } + if (reclen < 0) + reclen = 0; + for (i = reclen; i < dwidth; i++) + fputs(opt_border > 0 ? lformat->hrule : " ", fout); + if (opt_border == 2) + fprintf(fout, "%s%s", lformat->hrule, lformat->rightvrule); + fputc('\n', fout); +} + +static void +print_aligned_vertical(const printTableContent *cont, + FILE *fout, bool is_pager) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + const printTextFormat *format = get_line_style(cont->opt); + const printTextLineFormat *dformat = &format->lrule[PRINT_RULE_DATA]; + int encoding = cont->opt->encoding; + unsigned long record = cont->opt->prior_records + 1; + const char *const *ptr; + unsigned int i, + hwidth = 0, + dwidth = 0, + hheight = 1, + dheight = 1, + hformatsize = 0, + dformatsize = 0; + struct lineptr *hlineptr, + *dlineptr; + bool is_local_pager = false, + hmultiline = false, + dmultiline = false; + int output_columns = 0; /* Width of interactive console */ + + if (cancel_pressed) + return; + + if (opt_border > 2) + opt_border = 2; + + 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 (i = 0, ptr = cont->cells; *ptr; ptr++, i++) + { + 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(format, opt_border, record++, + lhwidth, dwidth, pos, fout); + else if (i != 0 || !cont->opt->start_table || opt_border == 2) + print_aligned_vertical_line(format, opt_border, 0, lhwidth, + dwidth, 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(format, opt_border, 0, hwidth, dwidth, + PRINT_RULE_BOTTOM, fout); + + /* print footers */ + if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + if (opt_border < 2) + fputc('\n', fout); + for (f = cont->footers; f; f = f->next) + fprintf(fout, "%s\n", f->data); + } + + fputc('\n', fout); + } + + free(hlineptr->ptr); + free(dlineptr->ptr); + free(hlineptr); + free(dlineptr); + + if (is_local_pager) + ClosePager(fout); +} + + +/**********************/ +/* CSV format */ +/**********************/ + + +static void +csv_escaped_print(const char *str, FILE *fout) +{ + const char *p; + + fputc('"', fout); + for (p = str; *p; p++) + { + if (*p == '"') + fputc('"', fout); /* double quotes are doubled */ + fputc(*p, fout); + } + fputc('"', fout); +} + +static void +csv_print_field(const char *str, FILE *fout, char sep) +{ + /*---------------- + * Enclose and escape field contents when one of these conditions is met: + * - the field separator is found in the contents. + * - the field contains a CR or LF. + * - the field contains a double quote. + * - the field is exactly "\.". + * - the field separator is either "\" or ".". + * The last two cases prevent producing a line that the server's COPY + * command would interpret as an end-of-data marker. We only really + * need to ensure that the complete line isn't exactly "\.", but for + * simplicity we apply stronger restrictions here. + *---------------- + */ + if (strchr(str, sep) != NULL || + strcspn(str, "\r\n\"") != strlen(str) || + strcmp(str, "\\.") == 0 || + sep == '\\' || sep == '.') + csv_escaped_print(str, fout); + else + fputs(str, fout); +} + +static void +print_csv_text(const printTableContent *cont, FILE *fout) +{ + const char *const *ptr; + int i; + + if (cancel_pressed) + return; + + /* + * The title and footer are never printed in csv format. The header is + * printed if opt_tuples_only is false. + * + * Despite RFC 4180 saying that end of lines are CRLF, terminate lines + * with '\n', which prints out as the system-dependent EOL string in text + * mode (typically LF on Unix and CRLF on Windows). + */ + if (cont->opt->start_table && !cont->opt->tuples_only) + { + /* print headers */ + for (ptr = cont->headers; *ptr; ptr++) + { + if (ptr != cont->headers) + fputc(cont->opt->csvFieldSep[0], fout); + csv_print_field(*ptr, fout, cont->opt->csvFieldSep[0]); + } + fputc('\n', fout); + } + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + csv_print_field(*ptr, fout, cont->opt->csvFieldSep[0]); + if ((i + 1) % cont->ncolumns) + fputc(cont->opt->csvFieldSep[0], fout); + else + fputc('\n', fout); + } +} + +static void +print_csv_vertical(const printTableContent *cont, FILE *fout) +{ + const char *const *ptr; + int i; + + /* print records */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (cancel_pressed) + return; + + /* print name of column */ + csv_print_field(cont->headers[i % cont->ncolumns], fout, + cont->opt->csvFieldSep[0]); + + /* print field separator */ + fputc(cont->opt->csvFieldSep[0], fout); + + /* print field value */ + csv_print_field(*ptr, fout, cont->opt->csvFieldSep[0]); + + fputc('\n', fout); + } +} + + +/**********************/ +/* HTML */ +/**********************/ + + +void +html_escaped_print(const char *in, FILE *fout) +{ + const char *p; + bool leading_space = true; + + for (p = in; *p; p++) + { + switch (*p) + { + case '&': + fputs("&", fout); + break; + case '<': + fputs("<", fout); + break; + case '>': + fputs(">", fout); + break; + case '\n': + fputs("<br />\n", fout); + break; + case '"': + fputs(""", fout); + break; + case ' ': + /* protect leading space, for EXPLAIN output */ + if (leading_space) + fputs(" ", fout); + else + fputs(" ", fout); + break; + default: + fputc(*p, fout); + } + if (*p != ' ') + leading_space = false; + } +} + + +static void +print_html_text(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + const char *opt_table_attr = cont->opt->tableAttr; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (cont->opt->start_table) + { + fprintf(fout, "<table border=\"%d\"", opt_border); + if (opt_table_attr) + fprintf(fout, " %s", opt_table_attr); + fputs(">\n", fout); + + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(" <caption>", fout); + html_escaped_print(cont->title, fout); + fputs("</caption>\n", fout); + } + + /* print headers */ + if (!opt_tuples_only) + { + fputs(" <tr>\n", fout); + for (ptr = cont->headers; *ptr; ptr++) + { + fputs(" <th align=\"center\">", fout); + html_escaped_print(*ptr, fout); + fputs("</th>\n", fout); + } + fputs(" </tr>\n", fout); + } + } + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (i % cont->ncolumns == 0) + { + if (cancel_pressed) + break; + fputs(" <tr valign=\"top\">\n", fout); + } + + fprintf(fout, " <td align=\"%s\">", cont->aligns[(i) % cont->ncolumns] == 'r' ? "right" : "left"); + /* is string only whitespace? */ + if ((*ptr)[strspn(*ptr, " \t")] == '\0') + fputs(" ", fout); + else + html_escaped_print(*ptr, fout); + + fputs("</td>\n", fout); + + if ((i + 1) % cont->ncolumns == 0) + fputs(" </tr>\n", fout); + } + + if (cont->opt->stop_table) + { + printTableFooter *footers = footers_with_default(cont); + + fputs("</table>\n", fout); + + /* print footers */ + if (!opt_tuples_only && footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + fputs("<p>", fout); + for (f = footers; f; f = f->next) + { + html_escaped_print(f->data, fout); + fputs("<br />\n", fout); + } + fputs("</p>", fout); + } + + fputc('\n', fout); + } +} + + +static void +print_html_vertical(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + const char *opt_table_attr = cont->opt->tableAttr; + unsigned long record = cont->opt->prior_records + 1; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (cont->opt->start_table) + { + fprintf(fout, "<table border=\"%d\"", opt_border); + if (opt_table_attr) + fprintf(fout, " %s", opt_table_attr); + fputs(">\n", fout); + + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(" <caption>", fout); + html_escaped_print(cont->title, fout); + fputs("</caption>\n", fout); + } + } + + /* print records */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (i % cont->ncolumns == 0) + { + if (cancel_pressed) + break; + if (!opt_tuples_only) + fprintf(fout, + "\n <tr><td colspan=\"2\" align=\"center\">Record %lu</td></tr>\n", + record++); + else + fputs("\n <tr><td colspan=\"2\"> </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(" ", fout); + else + html_escaped_print(*ptr, fout); + + fputs("</td>\n </tr>\n", fout); + } + + if (cont->opt->stop_table) + { + fputs("</table>\n", fout); + + /* print footers */ + if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + fputs("<p>", fout); + for (f = cont->footers; f; f = f->next) + { + html_escaped_print(f->data, fout); + fputs("<br />\n", fout); + } + fputs("</p>", fout); + } + + fputc('\n', fout); + } +} + + +/*************************/ +/* ASCIIDOC */ +/*************************/ + + +static void +asciidoc_escaped_print(const char *in, FILE *fout) +{ + const char *p; + + for (p = in; *p; p++) + { + switch (*p) + { + case '|': + fputs("\\|", fout); + break; + default: + fputc(*p, fout); + } + } +} + +static void +print_asciidoc_text(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (cont->opt->start_table) + { + /* print table in new paragraph - enforce preliminary new line */ + fputs("\n", fout); + + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(".", fout); + fputs(cont->title, fout); + fputs("\n", fout); + } + + /* print table [] header definition */ + fprintf(fout, "[%scols=\"", !opt_tuples_only ? "options=\"header\"," : ""); + for (i = 0; i < cont->ncolumns; i++) + { + if (i != 0) + fputs(",", fout); + fprintf(fout, "%s", cont->aligns[(i) % cont->ncolumns] == 'r' ? ">l" : "<l"); + } + fputs("\"", fout); + switch (opt_border) + { + case 0: + fputs(",frame=\"none\",grid=\"none\"", fout); + break; + case 1: + fputs(",frame=\"none\"", fout); + break; + case 2: + fputs(",frame=\"all\",grid=\"all\"", fout); + break; + } + fputs("]\n", fout); + fputs("|====\n", fout); + + /* print headers */ + if (!opt_tuples_only) + { + for (ptr = cont->headers; *ptr; ptr++) + { + if (ptr != cont->headers) + fputs(" ", fout); + fputs("^l|", fout); + asciidoc_escaped_print(*ptr, fout); + } + fputs("\n", fout); + } + } + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (i % cont->ncolumns == 0) + { + if (cancel_pressed) + break; + } + + if (i % cont->ncolumns != 0) + fputs(" ", fout); + fputs("|", fout); + + /* protect against needless spaces */ + if ((*ptr)[strspn(*ptr, " \t")] == '\0') + { + if ((i + 1) % cont->ncolumns != 0) + fputs(" ", fout); + } + else + asciidoc_escaped_print(*ptr, fout); + + if ((i + 1) % cont->ncolumns == 0) + fputs("\n", fout); + } + + fputs("|====\n", fout); + + if (cont->opt->stop_table) + { + printTableFooter *footers = footers_with_default(cont); + + /* print footers */ + if (!opt_tuples_only && footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + fputs("\n....\n", fout); + for (f = footers; f; f = f->next) + { + fputs(f->data, fout); + fputs("\n", fout); + } + fputs("....\n", fout); + } + } +} + +static void +print_asciidoc_vertical(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned long record = cont->opt->prior_records + 1; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (cont->opt->start_table) + { + /* print table in new paragraph - enforce preliminary new line */ + fputs("\n", fout); + + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(".", fout); + fputs(cont->title, fout); + fputs("\n", fout); + } + + /* print table [] header definition */ + fputs("[cols=\"h,l\"", fout); + switch (opt_border) + { + case 0: + fputs(",frame=\"none\",grid=\"none\"", fout); + break; + case 1: + fputs(",frame=\"none\"", fout); + break; + case 2: + fputs(",frame=\"all\",grid=\"all\"", fout); + break; + } + fputs("]\n", fout); + fputs("|====\n", fout); + } + + /* print records */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + if (i % cont->ncolumns == 0) + { + if (cancel_pressed) + break; + if (!opt_tuples_only) + fprintf(fout, + "2+^|Record %lu\n", + record++); + else + fputs("2+|\n", fout); + } + + fputs("<l|", fout); + asciidoc_escaped_print(cont->headers[i % cont->ncolumns], fout); + + fprintf(fout, " %s|", cont->aligns[i % cont->ncolumns] == 'r' ? ">l" : "<l"); + /* is string only whitespace? */ + if ((*ptr)[strspn(*ptr, " \t")] == '\0') + fputs(" ", fout); + else + asciidoc_escaped_print(*ptr, fout); + fputs("\n", fout); + } + + fputs("|====\n", fout); + + if (cont->opt->stop_table) + { + /* print footers */ + if (!opt_tuples_only && cont->footers != NULL && !cancel_pressed) + { + printTableFooter *f; + + fputs("\n....\n", fout); + for (f = cont->footers; f; f = f->next) + { + fputs(f->data, fout); + fputs("\n", fout); + } + fputs("....\n", fout); + } + } +} + + +/*************************/ +/* LaTeX */ +/*************************/ + + +static void +latex_escaped_print(const char *in, FILE *fout) +{ + const char *p; + + for (p = in; *p; p++) + switch (*p) + { + /* + * We convert ASCII characters per the recommendations in + * Scott Pakin's "The Comprehensive LATEX Symbol List", + * available from CTAN. For non-ASCII, you're on your own. + */ + case '#': + fputs("\\#", fout); + break; + case '$': + fputs("\\$", fout); + break; + case '%': + fputs("\\%", fout); + break; + case '&': + fputs("\\&", fout); + break; + case '<': + fputs("\\textless{}", fout); + break; + case '>': + fputs("\\textgreater{}", fout); + break; + case '\\': + fputs("\\textbackslash{}", fout); + break; + case '^': + fputs("\\^{}", fout); + break; + case '_': + fputs("\\_", fout); + break; + case '{': + fputs("\\{", fout); + break; + case '|': + fputs("\\textbar{}", fout); + break; + case '}': + fputs("\\}", fout); + break; + case '~': + fputs("\\~{}", fout); + break; + case '\n': + /* This is not right, but doing it right seems too hard */ + fputs("\\\\", fout); + break; + default: + fputc(*p, fout); + } +} + + +static void +print_latex_text(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (opt_border > 3) + opt_border = 3; + + if (cont->opt->start_table) + { + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs("\\begin{center}\n", fout); + latex_escaped_print(cont->title, fout); + fputs("\n\\end{center}\n\n", fout); + } + + /* begin environment and set alignments and borders */ + fputs("\\begin{tabular}{", fout); + + if (opt_border >= 2) + fputs("| ", fout); + for (i = 0; i < cont->ncolumns; i++) + { + fputc(*(cont->aligns + i), fout); + if (opt_border != 0 && i < cont->ncolumns - 1) + fputs(" | ", fout); + } + if (opt_border >= 2) + fputs(" |", fout); + + fputs("}\n", fout); + + if (!opt_tuples_only && opt_border >= 2) + fputs("\\hline\n", fout); + + /* print headers */ + if (!opt_tuples_only) + { + for (i = 0, ptr = cont->headers; i < cont->ncolumns; i++, ptr++) + { + if (i != 0) + fputs(" & ", fout); + fputs("\\textit{", fout); + latex_escaped_print(*ptr, fout); + fputc('}', fout); + } + fputs(" \\\\\n", fout); + fputs("\\hline\n", fout); + } + } + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + latex_escaped_print(*ptr, fout); + + if ((i + 1) % cont->ncolumns == 0) + { + fputs(" \\\\\n", fout); + if (opt_border == 3) + fputs("\\hline\n", fout); + if (cancel_pressed) + break; + } + else + fputs(" & ", fout); + } + + if (cont->opt->stop_table) + { + printTableFooter *footers = footers_with_default(cont); + + if (opt_border == 2) + fputs("\\hline\n", fout); + + fputs("\\end{tabular}\n\n\\noindent ", fout); + + /* print footers */ + if (footers && !opt_tuples_only && !cancel_pressed) + { + printTableFooter *f; + + for (f = footers; f; f = f->next) + { + latex_escaped_print(f->data, fout); + fputs(" \\\\\n", fout); + } + } + + fputc('\n', fout); + } +} + + +/*************************/ +/* LaTeX longtable */ +/*************************/ + + +static void +print_latex_longtable_text(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned int i; + const char *opt_table_attr = cont->opt->tableAttr; + const char *next_opt_table_attr_char = opt_table_attr; + const char *last_opt_table_attr_char = NULL; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (opt_border > 3) + opt_border = 3; + + if (cont->opt->start_table) + { + /* begin environment and set alignments and borders */ + fputs("\\begin{longtable}{", fout); + + if (opt_border >= 2) + fputs("| ", fout); + + for (i = 0; i < cont->ncolumns; i++) + { + /* longtable supports either a width (p) or an alignment (l/r) */ + /* Are we left-justified and was a proportional width specified? */ + if (*(cont->aligns + i) == 'l' && opt_table_attr) + { +#define LONGTABLE_WHITESPACE " \t\n" + + /* advance over whitespace */ + next_opt_table_attr_char += strspn(next_opt_table_attr_char, + LONGTABLE_WHITESPACE); + /* We have a value? */ + if (next_opt_table_attr_char[0] != '\0') + { + fputs("p{", fout); + fwrite(next_opt_table_attr_char, strcspn(next_opt_table_attr_char, + LONGTABLE_WHITESPACE), 1, fout); + last_opt_table_attr_char = next_opt_table_attr_char; + next_opt_table_attr_char += strcspn(next_opt_table_attr_char, + LONGTABLE_WHITESPACE); + fputs("\\textwidth}", fout); + } + /* use previous value */ + else if (last_opt_table_attr_char != NULL) + { + fputs("p{", fout); + fwrite(last_opt_table_attr_char, strcspn(last_opt_table_attr_char, + LONGTABLE_WHITESPACE), 1, fout); + fputs("\\textwidth}", fout); + } + else + fputc('l', fout); + } + else + fputc(*(cont->aligns + i), fout); + + if (opt_border != 0 && i < cont->ncolumns - 1) + fputs(" | ", fout); + } + + if (opt_border >= 2) + fputs(" |", fout); + + fputs("}\n", fout); + + /* print headers */ + if (!opt_tuples_only) + { + /* firsthead */ + if (opt_border >= 2) + fputs("\\toprule\n", fout); + for (i = 0, ptr = cont->headers; i < cont->ncolumns; i++, ptr++) + { + if (i != 0) + fputs(" & ", fout); + fputs("\\small\\textbf{\\textit{", fout); + latex_escaped_print(*ptr, fout); + fputs("}}", fout); + } + fputs(" \\\\\n", fout); + fputs("\\midrule\n\\endfirsthead\n", fout); + + /* secondary heads */ + if (opt_border >= 2) + fputs("\\toprule\n", fout); + for (i = 0, ptr = cont->headers; i < cont->ncolumns; i++, ptr++) + { + if (i != 0) + fputs(" & ", fout); + fputs("\\small\\textbf{\\textit{", fout); + latex_escaped_print(*ptr, fout); + fputs("}}", fout); + } + fputs(" \\\\\n", fout); + /* If the line under the row already appeared, don't do another */ + if (opt_border != 3) + fputs("\\midrule\n", fout); + fputs("\\endhead\n", fout); + + /* table name, caption? */ + if (!opt_tuples_only && cont->title) + { + /* Don't output if we are printing a line under each row */ + if (opt_border == 2) + fputs("\\bottomrule\n", fout); + fputs("\\caption[", fout); + latex_escaped_print(cont->title, fout); + fputs(" (Continued)]{", fout); + latex_escaped_print(cont->title, fout); + fputs("}\n\\endfoot\n", fout); + if (opt_border == 2) + fputs("\\bottomrule\n", fout); + fputs("\\caption[", fout); + latex_escaped_print(cont->title, fout); + fputs("]{", fout); + latex_escaped_print(cont->title, fout); + fputs("}\n\\endlastfoot\n", fout); + } + /* output bottom table line? */ + else if (opt_border >= 2) + { + fputs("\\bottomrule\n\\endfoot\n", fout); + fputs("\\bottomrule\n\\endlastfoot\n", fout); + } + } + } + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + /* Add a line under each row? */ + if (i != 0 && i % cont->ncolumns != 0) + fputs("\n&\n", fout); + fputs("\\raggedright{", fout); + latex_escaped_print(*ptr, fout); + fputc('}', fout); + if ((i + 1) % cont->ncolumns == 0) + { + fputs(" \\tabularnewline\n", fout); + if (opt_border == 3) + fputs(" \\hline\n", fout); + } + if (cancel_pressed) + break; + } + + if (cont->opt->stop_table) + fputs("\\end{longtable}\n", fout); +} + + +static void +print_latex_vertical(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned long record = cont->opt->prior_records + 1; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (opt_border > 2) + opt_border = 2; + + if (cont->opt->start_table) + { + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs("\\begin{center}\n", fout); + latex_escaped_print(cont->title, fout); + fputs("\n\\end{center}\n\n", fout); + } + + /* begin environment and set alignments and borders */ + fputs("\\begin{tabular}{", fout); + if (opt_border == 0) + fputs("cl", fout); + else if (opt_border == 1) + fputs("c|l", fout); + else if (opt_border == 2) + fputs("|c|l|", fout); + fputs("}\n", fout); + } + + /* print records */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + /* new record */ + if (i % cont->ncolumns == 0) + { + if (cancel_pressed) + break; + if (!opt_tuples_only) + { + if (opt_border == 2) + { + fputs("\\hline\n", fout); + fprintf(fout, "\\multicolumn{2}{|c|}{\\textit{Record %lu}} \\\\\n", record++); + } + else + fprintf(fout, "\\multicolumn{2}{c}{\\textit{Record %lu}} \\\\\n", record++); + } + if (opt_border >= 1) + fputs("\\hline\n", fout); + } + + latex_escaped_print(cont->headers[i % cont->ncolumns], fout); + fputs(" & ", fout); + latex_escaped_print(*ptr, fout); + fputs(" \\\\\n", fout); + } + + if (cont->opt->stop_table) + { + if (opt_border == 2) + fputs("\\hline\n", fout); + + fputs("\\end{tabular}\n\n\\noindent ", fout); + + /* print footers */ + if (cont->footers && !opt_tuples_only && !cancel_pressed) + { + printTableFooter *f; + + for (f = cont->footers; f; f = f->next) + { + latex_escaped_print(f->data, fout); + fputs(" \\\\\n", fout); + } + } + + fputc('\n', fout); + } +} + + +/*************************/ +/* Troff -ms */ +/*************************/ + + +static void +troff_ms_escaped_print(const char *in, FILE *fout) +{ + const char *p; + + for (p = in; *p; p++) + switch (*p) + { + case '\\': + fputs("\\(rs", fout); + break; + default: + fputc(*p, fout); + } +} + + +static void +print_troff_ms_text(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned int i; + const char *const *ptr; + + if (cancel_pressed) + return; + + if (opt_border > 2) + opt_border = 2; + + if (cont->opt->start_table) + { + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(".LP\n.DS C\n", fout); + troff_ms_escaped_print(cont->title, fout); + fputs("\n.DE\n", fout); + } + + /* begin environment and set alignments and borders */ + fputs(".LP\n.TS\n", fout); + if (opt_border == 2) + fputs("center box;\n", fout); + else + fputs("center;\n", fout); + + for (i = 0; i < cont->ncolumns; i++) + { + fputc(*(cont->aligns + i), fout); + if (opt_border > 0 && i < cont->ncolumns - 1) + fputs(" | ", fout); + } + fputs(".\n", fout); + + /* print headers */ + if (!opt_tuples_only) + { + for (i = 0, ptr = cont->headers; i < cont->ncolumns; i++, ptr++) + { + if (i != 0) + fputc('\t', fout); + fputs("\\fI", fout); + troff_ms_escaped_print(*ptr, fout); + fputs("\\fP", fout); + } + fputs("\n_\n", fout); + } + } + + /* print cells */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + troff_ms_escaped_print(*ptr, fout); + + if ((i + 1) % cont->ncolumns == 0) + { + fputc('\n', fout); + if (cancel_pressed) + break; + } + else + fputc('\t', fout); + } + + if (cont->opt->stop_table) + { + printTableFooter *footers = footers_with_default(cont); + + fputs(".TE\n.DS L\n", fout); + + /* print footers */ + if (footers && !opt_tuples_only && !cancel_pressed) + { + printTableFooter *f; + + for (f = footers; f; f = f->next) + { + troff_ms_escaped_print(f->data, fout); + fputc('\n', fout); + } + } + + fputs(".DE\n", fout); + } +} + + +static void +print_troff_ms_vertical(const printTableContent *cont, FILE *fout) +{ + bool opt_tuples_only = cont->opt->tuples_only; + unsigned short opt_border = cont->opt->border; + unsigned long record = cont->opt->prior_records + 1; + unsigned int i; + const char *const *ptr; + unsigned short current_format = 0; /* 0=none, 1=header, 2=body */ + + if (cancel_pressed) + return; + + if (opt_border > 2) + opt_border = 2; + + if (cont->opt->start_table) + { + /* print title */ + if (!opt_tuples_only && cont->title) + { + fputs(".LP\n.DS C\n", fout); + troff_ms_escaped_print(cont->title, fout); + fputs("\n.DE\n", fout); + } + + /* begin environment and set alignments and borders */ + fputs(".LP\n.TS\n", fout); + if (opt_border == 2) + fputs("center box;\n", fout); + else + fputs("center;\n", fout); + + /* basic format */ + if (opt_tuples_only) + fputs("c l;\n", fout); + } + else + current_format = 2; /* assume tuples printed already */ + + /* print records */ + for (i = 0, ptr = cont->cells; *ptr; i++, ptr++) + { + /* new record */ + if (i % cont->ncolumns == 0) + { + if (cancel_pressed) + break; + if (!opt_tuples_only) + { + if (current_format != 1) + { + if (opt_border == 2 && record > 1) + fputs("_\n", fout); + if (current_format != 0) + fputs(".T&\n", fout); + fputs("c s.\n", fout); + current_format = 1; + } + fprintf(fout, "\\fIRecord %lu\\fP\n", record++); + } + if (opt_border >= 1) + fputs("_\n", fout); + } + + if (!opt_tuples_only) + { + if (current_format != 2) + { + if (current_format != 0) + fputs(".T&\n", fout); + if (opt_border != 1) + fputs("c l.\n", fout); + else + fputs("c | l.\n", fout); + current_format = 2; + } + } + + troff_ms_escaped_print(cont->headers[i % cont->ncolumns], fout); + fputc('\t', fout); + troff_ms_escaped_print(*ptr, fout); + + fputc('\n', fout); + } + + if (cont->opt->stop_table) + { + fputs(".TE\n.DS L\n", fout); + + /* print footers */ + if (cont->footers && !opt_tuples_only && !cancel_pressed) + { + printTableFooter *f; + + for (f = cont->footers; f; f = f->next) + { + troff_ms_escaped_print(f->data, fout); + fputc('\n', fout); + } + } + + fputs(".DE\n", fout); + } +} + + +/********************************/ +/* Public functions */ +/********************************/ + + +/* + * disable_sigpipe_trap + * + * Turn off SIGPIPE interrupt --- call this before writing to a temporary + * query output file that is a pipe. + * + * No-op on Windows, where there's no SIGPIPE interrupts. + */ +void +disable_sigpipe_trap(void) +{ +#ifndef WIN32 + pqsignal(SIGPIPE, SIG_IGN); +#endif +} + +/* + * restore_sigpipe_trap + * + * Restore normal SIGPIPE interrupt --- call this when done writing to a + * temporary query output file that was (or might have been) a pipe. + * + * Note: within psql, we enable SIGPIPE interrupts unless the permanent query + * output file is a pipe, in which case they should be kept off. This + * approach works only because psql is not currently complicated enough to + * have nested usages of short-lived output files. Otherwise we'd probably + * need a genuine save-and-restore-state approach; but for now, that would be + * useless complication. In non-psql programs, this always enables SIGPIPE. + * + * No-op on Windows, where there's no SIGPIPE interrupts. + */ +void +restore_sigpipe_trap(void) +{ +#ifndef WIN32 + pqsignal(SIGPIPE, always_ignore_sigpipe ? SIG_IGN : SIG_DFL); +#endif +} + +/* + * set_sigpipe_trap_state + * + * Set the trap state that restore_sigpipe_trap should restore to. + */ +void +set_sigpipe_trap_state(bool ignore) +{ + always_ignore_sigpipe = ignore; +} + + +/* + * PageOutput + * + * Tests if pager is needed and returns appropriate FILE pointer. + * + * If the topt argument is NULL no pager is used. + */ +FILE * +PageOutput(int lines, const printTableOpt *topt) +{ + /* 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; + } + disable_sigpipe_trap(); + pagerpipe = popen(pagerprog, "w"); + if (pagerpipe) + return pagerpipe; + /* if popen fails, silently proceed without pager */ + restore_sigpipe_trap(); + } + } + + return stdout; +} + +/* + * ClosePager + * + * Close previously opened pager pipe, if any + */ +void +ClosePager(FILE *pagerpipe) +{ + if (pagerpipe && pagerpipe != stdout) + { + /* + * If printing was canceled midstream, warn about it. + * + * Some pagers like less use Ctrl-C as part of their command set. Even + * so, we abort our processing and warn the user what we did. If the + * pager quit as a result of the SIGINT, this message won't go + * anywhere ... + */ + if (cancel_pressed) + fprintf(pagerpipe, _("Interrupted\n")); + + pclose(pagerpipe); + restore_sigpipe_trap(); + } +} + +/* + * Initialise a table contents struct. + * Must be called before any other printTable method is used. + * + * The title is not duplicated; the caller must ensure that the buffer + * is available for the lifetime of the printTableContent struct. + * + * If you call this, you must call printTableCleanup once you're done with the + * table. + */ +void +printTableInit(printTableContent *const content, const printTableOpt *opt, + const char *title, const int ncolumns, const int nrows) +{ + content->opt = opt; + content->title = title; + content->ncolumns = ncolumns; + content->nrows = nrows; + + content->headers = pg_malloc0((ncolumns + 1) * sizeof(*content->headers)); + + content->cells = pg_malloc0((ncolumns * nrows + 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; +} + +/* + * Add a header to the table. + * + * Headers are not duplicated; you must ensure that the header string is + * available for the lifetime of the printTableContent struct. + * + * If translate is true, the function will pass the header through gettext. + * Otherwise, the header will not be translated. + * + * align is either 'l' or 'r', and specifies the alignment for cells in this + * column. + */ +void +printTableAddHeader(printTableContent *const content, char *header, + const bool translate, const char align) +{ +#ifndef ENABLE_NLS + (void) translate; /* unused parameter */ +#endif + + if (content->header >= content->headers + content->ncolumns) + { + fprintf(stderr, _("Cannot add header to table content: " + "column count of %d exceeded.\n"), + content->ncolumns); + exit(EXIT_FAILURE); + } + + *content->header = (char *) mbvalidate((unsigned char *) header, + content->opt->encoding); +#ifdef ENABLE_NLS + if (translate) + *content->header = _(*content->header); +#endif + content->header++; + + *content->align = align; + content->align++; +} + +/* + * Add a cell to the table. + * + * Cells are not duplicated; you must ensure that the cell string is available + * for the lifetime of the printTableContent struct. + * + * If translate is true, the function will pass the cell through gettext. + * Otherwise, the cell will not be translated. + * + * If mustfree is true, the cell string is freed by printTableCleanup(). + * Note: Automatic freeing of translatable strings is not supported. + */ +void +printTableAddCell(printTableContent *const content, char *cell, + const bool translate, const bool mustfree) +{ +#ifndef ENABLE_NLS + (void) translate; /* unused parameter */ +#endif + + if (content->cellsadded >= content->ncolumns * content->nrows) + { + fprintf(stderr, _("Cannot add cell to table content: " + "total cell count of %d exceeded.\n"), + content->ncolumns * content->nrows); + 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((content->ncolumns * content->nrows + 1) * sizeof(bool)); + + content->cellmustfree[content->cellsadded] = true; + } + content->cell++; + content->cellsadded++; +} + +/* + * Add a footer to the table. + * + * Footers are added as elements of a singly-linked list, and the content is + * strdup'd, so there is no need to keep the original footer string around. + * + * Footers are never translated by the function. If you want the footer + * translated you must do so yourself, before calling printTableAddFooter. The + * reason this works differently to headers and cells is that footers tend to + * be made of up individually translated components, rather than being + * translated as a whole. + */ +void +printTableAddFooter(printTableContent *const content, const char *footer) +{ + printTableFooter *f; + + f = pg_malloc0(sizeof(*f)); + f->data = pg_strdup(footer); + + if (content->footers == NULL) + content->footers = f; + else + content->footer->next = f; + + content->footer = f; +} + +/* + * Change the content of the last-added footer. + * + * The current contents of the last-added footer are freed, and replaced by the + * content given in *footer. If there was no previous footer, add a new one. + * + * The content is strdup'd, so there is no need to keep the original string + * around. + */ +void +printTableSetFooter(printTableContent *const content, const char *footer) +{ + if (content->footers != NULL) + { + free(content->footer->data); + content->footer->data = pg_strdup(footer); + } + else + printTableAddFooter(content, footer); +} + +/* + * Free all memory allocated to this struct. + * + * Once this has been called, the struct is unusable unless you pass it to + * printTableInit() again. + */ +void +printTableCleanup(printTableContent *const content) +{ + if (content->cellmustfree) + { + int i; + + for (i = 0; i < content->nrows * content->ncolumns; i++) + { + if (content->cellmustfree[i]) + free(unconstify(char *, content->cells[i])); + } + free(content->cellmustfree); + content->cellmustfree = NULL; + } + free(content->headers); + free(content->cells); + free(content->aligns); + + content->opt = NULL; + content->title = NULL; + content->headers = NULL; + content->cells = NULL; + content->aligns = NULL; + content->header = NULL; + content->cell = NULL; + content->align = NULL; + + if (content->footers) + { + for (content->footer = content->footers; content->footer;) + { + printTableFooter *f; + + f = content->footer; + content->footer = f->next; + free(f->data); + free(f); + } + } + content->footers = NULL; + content->footer = NULL; +} + +/* + * IsPagerNeeded + * + * Setup pager if required + */ +static void +IsPagerNeeded(const printTableContent *cont, int extra_lines, bool expanded, + FILE **fout, bool *is_pager) +{ + 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; +} + +/* + * Use this to print any table in the supported formats. + * + * cont: table data and formatting options + * fout: where to print to + * is_pager: true if caller has already redirected fout to be a pager pipe + * flog: if not null, also print the table there (for --log-file option) + */ +void +printTable(const printTableContent *cont, + FILE *fout, bool is_pager, FILE *flog) +{ + bool is_local_pager = false; + + if (cancel_pressed) + return; + + if (cont->opt->format == PRINT_NOTHING) + return; + + /* print_aligned_*() handle the pager themselves */ + if (!is_pager && + cont->opt->format != PRINT_ALIGNED && + cont->opt->format != PRINT_WRAPPED) + { + IsPagerNeeded(cont, 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); +} + +/* + * Use this to print query results + * + * result: result of a successful query + * opt: formatting options + * fout: where to print to + * is_pager: true if caller has already redirected fout to be a pager pipe + * flog: if not null, also print the data there (for --log-file option) + */ +void +printQuery(const PGresult *result, const printQueryOpt *opt, + FILE *fout, bool is_pager, FILE *flog) +{ + printTableContent cont; + int i, + r, + c; + + if (cancel_pressed) + return; + + printTableInit(&cont, &opt->topt, opt->title, + PQnfields(result), PQntuples(result)); + + /* Assert caller supplied enough translate_columns[] entries */ + Assert(opt->translate_columns == NULL || + opt->n_translate_columns >= cont.ncolumns); + + for (i = 0; i < cont.ncolumns; i++) + { + printTableAddHeader(&cont, PQfname(result, i), + opt->translate_header, + column_type_alignment(PQftype(result, i))); + } + + /* set cells */ + for (r = 0; r < cont.nrows; r++) + { + for (c = 0; c < cont.ncolumns; c++) + { + char *cell; + bool mustfree = false; + bool translate; + + if (PQgetisnull(result, r, c)) + cell = opt->nullPrint ? opt->nullPrint : ""; + else + { + cell = PQgetvalue(result, r, c); + if (cont.aligns[c] == 'r' && opt->topt.numericLocale) + { + cell = format_numeric_locale(cell); + mustfree = true; + } + } + + translate = (opt->translate_columns && opt->translate_columns[c]); + printTableAddCell(&cont, cell, translate, mustfree); + } + } + + /* set footers */ + if (opt->footers) + { + char **footer; + + for (footer = opt->footers; *footer; footer++) + printTableAddFooter(&cont, *footer); + } + + printTable(&cont, fout, is_pager, flog); + printTableCleanup(&cont); +} + +char +column_type_alignment(Oid ftype) +{ + char align; + + switch (ftype) + { + case INT2OID: + case INT4OID: + case INT8OID: + case FLOAT4OID: + case FLOAT8OID: + case NUMERICOID: + case OIDOID: + case XIDOID: + case XID8OID: + case CIDOID: + case MONEYOID: + align = 'r'; + break; + default: + align = 'l'; + break; + } + return align; +} + +void +setDecimalLocale(void) +{ + struct lconv *extlconv; + + extlconv = localeconv(); + + /* Don't accept an empty decimal_point string */ + if (*extlconv->decimal_point) + decimal_point = pg_strdup(extlconv->decimal_point); + else + decimal_point = "."; /* SQL output standard */ + + /* + * Although the Open Group standard allows locales to supply more than one + * group width, we consider only the first one, and we ignore any attempt + * to suppress grouping by specifying CHAR_MAX. As in the backend's + * cash.c, we must apply a range check to avoid being fooled by variant + * CHAR_MAX values. + */ + groupdigits = *extlconv->grouping; + if (groupdigits <= 0 || groupdigits > 6) + groupdigits = 3; /* most common */ + + /* Don't accept an empty thousands_sep string, either */ + /* similar code exists in formatting.c */ + if (*extlconv->thousands_sep) + thousands_sep = pg_strdup(extlconv->thousands_sep); + /* Make sure thousands separator doesn't match decimal point symbol. */ + else if (strcmp(decimal_point, ",") != 0) + thousands_sep = ","; + else + thousands_sep = "."; +} + +/* get selected or default line style */ +const printTextFormat * +get_line_style(const printTableOpt *opt) +{ + /* + * Note: this function mainly exists to preserve the convention that a + * printTableOpt struct can be initialized to zeroes to get default + * behavior. + */ + if (opt->line_style != NULL) + return opt->line_style; + else + return &pg_asciiformat; +} + +void +refresh_utf8format(const printTableOpt *opt) +{ + printTextFormat *popt = &pg_utf8format; + + const unicodeStyleBorderFormat *border; + const unicodeStyleRowFormat *header; + const unicodeStyleColumnFormat *column; + + popt->name = "unicode"; + + border = &unicode_style.border_style[opt->unicode_border_linestyle]; + header = &unicode_style.row_style[opt->unicode_header_linestyle]; + column = &unicode_style.column_style[opt->unicode_column_linestyle]; + + popt->lrule[PRINT_RULE_TOP].hrule = border->horizontal; + popt->lrule[PRINT_RULE_TOP].leftvrule = border->down_and_right; + popt->lrule[PRINT_RULE_TOP].midvrule = column->down_and_horizontal[opt->unicode_border_linestyle]; + popt->lrule[PRINT_RULE_TOP].rightvrule = border->down_and_left; + + popt->lrule[PRINT_RULE_MIDDLE].hrule = header->horizontal; + popt->lrule[PRINT_RULE_MIDDLE].leftvrule = header->vertical_and_right[opt->unicode_border_linestyle]; + popt->lrule[PRINT_RULE_MIDDLE].midvrule = column->vertical_and_horizontal[opt->unicode_header_linestyle]; + popt->lrule[PRINT_RULE_MIDDLE].rightvrule = header->vertical_and_left[opt->unicode_border_linestyle]; + + popt->lrule[PRINT_RULE_BOTTOM].hrule = border->horizontal; + popt->lrule[PRINT_RULE_BOTTOM].leftvrule = border->up_and_right; + popt->lrule[PRINT_RULE_BOTTOM].midvrule = column->up_and_horizontal[opt->unicode_border_linestyle]; + popt->lrule[PRINT_RULE_BOTTOM].rightvrule = border->left_and_right; + + /* N/A */ + popt->lrule[PRINT_RULE_DATA].hrule = ""; + popt->lrule[PRINT_RULE_DATA].leftvrule = border->vertical; + popt->lrule[PRINT_RULE_DATA].midvrule = column->vertical; + popt->lrule[PRINT_RULE_DATA].rightvrule = border->vertical; + + popt->midvrule_nl = column->vertical; + popt->midvrule_wrap = column->vertical; + popt->midvrule_blank = column->vertical; + + /* Same for all unicode today */ + popt->header_nl_left = unicode_style.header_nl_left; + popt->header_nl_right = unicode_style.header_nl_right; + popt->nl_left = unicode_style.nl_left; + popt->nl_right = unicode_style.nl_right; + popt->wrap_left = unicode_style.wrap_left; + popt->wrap_right = unicode_style.wrap_right; + popt->wrap_right_border = unicode_style.wrap_right_border; +} + +/* + * Compute the byte distance to the end of the string or *target_width + * display character positions, whichever comes first. Update *target_width + * to be the number of display character positions actually filled. + */ +static int +strlen_max_width(unsigned char *str, int *target_width, int encoding) +{ + unsigned char *start = str; + unsigned char *end = str + strlen((char *) str); + int curr_width = 0; + + while (str < end) + { + int char_width = PQdsplen((char *) str, encoding); + + /* + * If the display width of the new character causes the string to + * exceed its target width, skip it and return. However, if this is + * the first character of the string (curr_width == 0), we have to + * accept it. + */ + if (*target_width < curr_width + char_width && curr_width != 0) + break; + + curr_width += char_width; + + str += PQmblen((char *) str, encoding); + + if (str > end) /* Don't overrun invalid string */ + str = end; + } + + *target_width = curr_width; + + return str - start; +} |