X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Fascii.c;h=76fb51544a965adf90e5931cfcc37e64e1c029d6;hb=f1db96caae4;hp=f6bc7a6f91b3bb6fbe96f920f46639ac5819071f;hpb=a19b858e0ac3c69e4a28c0ca6d8674427268a863;p=pspp diff --git a/src/output/ascii.c b/src/output/ascii.c index f6bc7a6f91..76fb51544a 100644 --- a/src/output/ascii.c +++ b/src/output/ascii.c @@ -1,1692 +1,1174 @@ -/* PSPP - computes sample statistics. - Copyright (C) 1997-9, 2000 Free Software Foundation, Inc. - Written by Ben Pfaff . +/* PSPP - a program for statistical analysis. + Copyright (C) 1997-9, 2000, 2007, 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc. - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 2 of the - License, or (at your option) any later version. + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ + along with this program. If not, see . */ #include -#include + #include #include #include +#include #include -#include -#include -#include "chart.h" -#include -#include -#include -#include "output.h" -#include -#include -#include +#include +#include +#include +#include +#include + +#include "data/file-name.h" +#include "data/settings.h" +#include "libpspp/assertion.h" +#include "libpspp/cast.h" +#include "libpspp/compiler.h" +#include "libpspp/message.h" +#include "libpspp/start-date.h" +#include "libpspp/string-map.h" +#include "libpspp/u8-line.h" +#include "libpspp/version.h" +#include "output/ascii.h" +#include "output/cairo.h" +#include "output/chart-item-provider.h" +#include "output/driver-provider.h" +#include "output/message-item.h" +#include "output/options.h" +#include "output/render.h" +#include "output/tab.h" +#include "output/table-item.h" +#include "output/text-item.h" + +#include "gl/minmax.h" +#include "gl/xalloc.h" #include "gettext.h" #define _(msgid) gettext (msgid) -/* ASCII driver options: (defaults listed first) - - output-file="pspp.list" - char-set=ascii|latin1 - form-feed-string="\f" Written as a formfeed. - newline-string=default|"\r\n"|"\n" - Written as a newline. - paginate=on|off Formfeeds are desired? - tab-width=8 Width of a tab; 0 to not use tabs. - init="" Written at beginning of output. - done="" Written at end of output. - - headers=on|off Put headers at top of page? - length=66 - width=130 - lpi=6 Only used to determine font size. - cpi=10 - squeeze=off|on Squeeze multiple newlines into exactly one. - - left-margin=0 - right-margin=0 - top-margin=2 - bottom-margin=2 - - box[x]="strng" Sets box character X (X in base 4: 0-3333). - italic-on=overstrike|"strng" Turns on italic (underline). - italic-off=""|"strng" Turns off italic; ignored for overstrike. - bold-on=overstrike|"strng" Turns on bold. - bold-off=""|"strng" Turns off bold; ignored for overstrike. - bold-italic-on=overstrike|"strng" Turns on bold-italic. - bold-italic-off=""|"strng" Turns off bold-italic; ignored for overstrike. - overstrike-style=single|line Can we print a whole line then BS over it, or - must we go char by char, as on a terminal? - carriage-return-style=bs|cr Must we return the carriage with a sequence of - BSes, or will a single CR do it? - */ - -/* Disable messages by failed range checks. */ -/*#define SUPPRESS_WARNINGS 1 */ - -/* Character set. */ -enum - { - CHS_ASCII, /* 7-bit ASCII */ - CHS_LATIN1 /* Latin 1; not really supported at the moment */ - }; +/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */ +#define H TABLE_HORZ +#define V TABLE_VERT -/* Overstrike style. */ -enum - { - OVS_SINGLE, /* Overstrike each character: "a\b_b\b_c\b_" */ - OVS_LINE /* Overstrike lines: "abc\b\b\b___" (or if - newline is "\r\n", then "abc\r___"). Easier - on the printer, doesn't work on a tty. */ - }; +#define N_BOX (RENDER_N_LINES * RENDER_N_LINES \ + * RENDER_N_LINES * RENDER_N_LINES) -/* Basic output strings. */ -enum +static const ucs4_t ascii_box_chars[N_BOX] = { - OPS_INIT, /* Document initialization string. */ - OPS_DONE, /* Document uninit string. */ - OPS_FORMFEED, /* Formfeed string. */ - OPS_NEWLINE, /* Newline string. */ - - OPS_COUNT /* Number of output strings. */ + ' ', '|', '#', + '-', '+', '#', + '=', '#', '#', + '|', '|', '#', + '+', '+', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '-', '+', '#', + '-', '+', '#', + '#', '#', '#', + '+', '+', '#', + '+', '+', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '=', '#', '#', + '#', '#', '#', + '=', '#', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', + '#', '#', '#', }; -/* Line styles bit shifts. */ -enum +static const ucs4_t unicode_box_chars[N_BOX] = { - LNS_TOP = 0, - LNS_LEFT = 2, - LNS_BOTTOM = 4, - LNS_RIGHT = 6, - - LNS_COUNT = 256 + 0x0020, 0x2575, 0x2551, + 0x2574, 0x256f, 0x255c, + 0x2550, 0x255b, 0x255d, + 0x2577, 0x2502, 0x2551, + 0x256e, 0x2524, 0x2562, + 0x2555, 0x2561, 0x2563, + 0x2551, 0x2551, 0x2551, + 0x2556, 0x2562, 0x2562, + 0x2557, 0x2563, 0x2563, + 0x2576, 0x2570, 0x2559, + 0x2500, 0x2534, 0x2568, + 0x2550, 0x2567, 0x2569, + 0x256d, 0x251c, 0x255f, + 0x252c, 0x253c, 0x256a, + 0x2564, 0x256a, 0x256c, + 0x2553, 0x255f, 0x255f, + 0x2565, 0x256b, 0x256b, + 0x2566, 0x256c, 0x256c, + 0x2550, 0x2558, 0x255a, + 0x2550, 0x2567, 0x2569, + 0x2550, 0x2567, 0x2569, + 0x2552, 0x255e, 0x2560, + 0x2564, 0x256a, 0x256c, + 0x2564, 0x256a, 0x256c, + 0x2554, 0x2560, 0x2560, + 0x2560, 0x256c, 0x256c, + 0x2566, 0x256c, 0x256c, }; -/* Carriage return style. */ -enum - { - CRS_BS, /* Multiple backspaces. */ - CRS_CR /* Single carriage return. */ - }; - -/* Assembles a byte from four taystes. */ -#define TAYSTE2BYTE(T, L, B, R) \ - (((T) << LNS_TOP) \ - | ((L) << LNS_LEFT) \ - | ((B) << LNS_BOTTOM) \ - | ((R) << LNS_RIGHT)) - -/* Extract tayste with shift value S from byte B. */ -#define BYTE2TAYSTE(B, S) \ - (((B) >> (S)) & 3) +static inline int +make_box_index (int left, int right, int top, int bottom) +{ + return ((right * RENDER_N_LINES + bottom) * RENDER_N_LINES + left) * RENDER_N_LINES + top; +} -/* Font style; take one of the first group |'d with one of the second group. */ -enum +/* How to emphasize text. */ +enum emphasis_style { - FSTY_ON = 000, /* Turn font on. */ - FSTY_OFF = 001, /* Turn font off. */ - - FSTY_ITALIC = 0, /* Italic font. */ - FSTY_BOLD = 2, /* Bold font. */ - FSTY_BOLD_ITALIC = 4, /* Bold-italic font. */ - - FSTY_COUNT = 6 /* Number of font styles. */ + EMPH_BOLD, /* Overstrike for bold. */ + EMPH_UNDERLINE, /* Overstrike for underlining. */ + EMPH_NONE /* No emphasis. */ }; -/* A line of text. */ -struct line +/* ASCII output driver. */ +struct ascii_driver { - unsigned short *chars; /* Characters and attributes. */ - int char_cnt; /* Length. */ - int char_cap; /* Allocated bytes. */ - }; + struct output_driver driver; -/* ASCII output driver extension record. */ -struct ascii_driver_ext - { /* User parameters. */ - int char_set; /* CHS_ASCII/CHS_LATIN1; no-op right now. */ - int headers; /* 1=print headers at top of page. */ - int page_length; /* Page length in lines. */ - int page_width; /* Page width in characters. */ - int lpi; /* Lines per inch. */ - int cpi; /* Characters per inch. */ - int left_margin; /* Left margin in characters. */ - int right_margin; /* Right margin in characters. */ + bool append; /* Append if output file already exists? */ + bool headers; /* Print headers at top of page? */ + bool paginate; /* Insert formfeeds? */ + bool squeeze_blank_lines; /* Squeeze multiple blank lines into one? */ + enum emphasis_style emphasis; /* How to emphasize text. */ + char *chart_file_name; /* Name of files used for charts. */ + +#ifdef HAVE_CAIRO + /* Colours for charts */ + struct xr_color fg; + struct xr_color bg; +#endif + + int width; /* Page width. */ + int length; /* Page length minus margins and header. */ + bool auto_width; /* Use viewwidth as page width? */ + bool auto_length; /* Use viewlength as page width? */ + int top_margin; /* Top margin in lines. */ int bottom_margin; /* Bottom margin in lines. */ - int paginate; /* 1=insert formfeeds. */ - int tab_width; /* Width of a tab; 0 not to use tabs. */ - struct fixed_string ops[OPS_COUNT]; /* Basic output strings. */ - struct fixed_string box[LNS_COUNT]; /* Line & box drawing characters. */ - struct fixed_string fonts[FSTY_COUNT]; /* Font styles; NULL=overstrike. */ - int overstrike_style; /* OVS_SINGLE or OVS_LINE. */ - int carriage_return_style; /* Carriage return style. */ - int squeeze_blank_lines; /* 1=squeeze multiple blank lines into one. */ + + int min_break[TABLE_N_AXES]; /* Min cell size to break across pages. */ + + const ucs4_t *box; /* Line & box drawing characters. */ /* Internal state. */ - struct file_ext file; /* Output file. */ + char *command_name; + char *title; + char *subtitle; + char *file_name; /* Output file name. */ + FILE *file; /* Output file. */ + bool error; /* Output error? */ int page_number; /* Current page number. */ - struct line *lines; /* Page content. */ - int lines_cap; /* Number of lines allocated. */ - int w, l; /* Actual width & length w/o margins, etc. */ - int cur_font; /* Current font by OUTP_F_*. */ -#if DEBUGGING - int debug; /* Set by som_text_draw(). */ -#endif + struct u8_line *lines; /* Page content. */ + int allocated_lines; /* Number of lines allocated. */ + int chart_cnt; /* Number of charts so far. */ + int x, y; }; -static int postopen (struct file_ext *); -static int preclose (struct file_ext *); +static const struct output_driver_class ascii_driver_class; -static struct outp_option_info *option_info; +static void ascii_submit (struct output_driver *, const struct output_item *); -static int -ascii_open_global (struct outp_class *this UNUSED) +static int vertical_margins (const struct ascii_driver *); + +static bool update_page_size (struct ascii_driver *, bool issue_error); +static int parse_page_size (struct driver_option *); + +static void ascii_close_page (struct ascii_driver *); +static bool ascii_open_page (struct ascii_driver *); + +static void ascii_draw_line (void *, int bb[TABLE_N_AXES][2], + enum render_line_style styles[TABLE_N_AXES][2]); +static void ascii_measure_cell_width (void *, const struct table_cell *, + int *min, int *max); +static int ascii_measure_cell_height (void *, const struct table_cell *, + int width); +static void ascii_draw_cell (void *, const struct table_cell *, + int bb[TABLE_N_AXES][2], + int clip[TABLE_N_AXES][2]); + +static void +reallocate_lines (struct ascii_driver *a) { - option_info = xmalloc (sizeof *option_info); - option_info->initial = 0; - option_info->options = 0; - return 1; + if (a->length > a->allocated_lines) + { + int i; + a->lines = xnrealloc (a->lines, a->length, sizeof *a->lines); + for (i = a->allocated_lines; i < a->length; i++) + u8_line_init (&a->lines[i]); + a->allocated_lines = a->length; + } } -static char *s; -static int -ascii_close_global (struct outp_class *this UNUSED) +static struct ascii_driver * +ascii_driver_cast (struct output_driver *driver) { - free(option_info->initial); - free(option_info->options); - free(option_info); - free(s); - return 1; + assert (driver->class == &ascii_driver_class); + return UP_CAST (driver, struct ascii_driver, driver); } -static int * -ascii_font_sizes (struct outp_class *this UNUSED, int *n_valid_sizes) +static struct driver_option * +opt (struct output_driver *d, struct string_map *options, const char *key, + const char *default_value) { - static int valid_sizes[] = {12, 12, 0, 0}; - - assert (n_valid_sizes); - *n_valid_sizes = 1; - return valid_sizes; + return driver_option_get (d, options, key, default_value); } -static int -ascii_preopen_driver (struct outp_driver *this) +static struct output_driver * +ascii_create (const char *file_name, enum settings_output_devices device_type, + struct string_map *o) { - struct ascii_driver_ext *x; - int i; - - assert (this->driver_open == 0); - msg (VM (1), _("ASCII driver initializing as `%s'..."), this->name); - this->ext = x = xmalloc (sizeof *x); - x->char_set = CHS_ASCII; - x->headers = 1; - x->page_length = 66; - x->page_width = 79; - x->lpi = 6; - x->cpi = 10; - x->left_margin = 0; - x->right_margin = 0; - x->top_margin = 2; - x->bottom_margin = 2; - x->paginate = 1; - x->tab_width = 8; - for (i = 0; i < OPS_COUNT; i++) - ls_null (&x->ops[i]); - for (i = 0; i < LNS_COUNT; i++) - ls_null (&x->box[i]); - for (i = 0; i < FSTY_COUNT; i++) - ls_null (&x->fonts[i]); - x->overstrike_style = OVS_SINGLE; - x->carriage_return_style = CRS_BS; - x->squeeze_blank_lines = 0; - x->file.filename = NULL; - x->file.mode = "wb"; - x->file.file = NULL; - x->file.sequence_no = &x->page_number; - x->file.param = x; - x->file.postopen = postopen; - x->file.preclose = preclose; - x->page_number = 0; - x->lines = NULL; - x->lines_cap = 0; - x->cur_font = OUTP_F_R; -#if DEBUGGING - x->debug = 0; + enum { BOX_ASCII, BOX_UNICODE } box; + int min_break[TABLE_N_AXES]; + struct output_driver *d; + struct ascii_driver *a; + int paper_length; + + a = xzalloc (sizeof *a); + d = &a->driver; + output_driver_init (&a->driver, &ascii_driver_class, file_name, device_type); + a->append = parse_boolean (opt (d, o, "append", "false")); + a->headers = parse_boolean (opt (d, o, "headers", "false")); + a->paginate = parse_boolean (opt (d, o, "paginate", "false")); + a->squeeze_blank_lines = parse_boolean (opt (d, o, "squeeze", "true")); + a->emphasis = parse_enum (opt (d, o, "emphasis", "none"), + "bold", EMPH_BOLD, + "underline", EMPH_UNDERLINE, + "none", EMPH_NONE, + NULL_SENTINEL); + + a->chart_file_name = parse_chart_file_name (opt (d, o, "charts", file_name)); + + a->top_margin = parse_int (opt (d, o, "top-margin", "0"), 0, INT_MAX); + a->bottom_margin = parse_int (opt (d, o, "bottom-margin", "0"), 0, INT_MAX); + + min_break[H] = parse_int (opt (d, o, "min-hbreak", "-1"), -1, INT_MAX); + min_break[V] = parse_int (opt (d, o, "min-vbreak", "-1"), -1, INT_MAX); + + a->width = parse_page_size (opt (d, o, "width", "79")); + paper_length = parse_page_size (opt (d, o, "length", "66")); + a->auto_width = a->width < 0; + a->auto_length = paper_length < 0; + a->length = paper_length - vertical_margins (a); + a->min_break[H] = min_break[H] >= 0 ? min_break[H] : a->width / 2; + a->min_break[V] = min_break[V] >= 0 ? min_break[V] : a->length / 2; +#ifdef HAVE_CAIRO + parse_color (d, o, "background-color", "#FFFFFFFFFFFF", &a->bg); + parse_color (d, o, "foreground-color", "#000000000000", &a->fg); #endif - return 1; + box = parse_enum (opt (d, o, "box", "ascii"), + "ascii", BOX_ASCII, + "unicode", BOX_UNICODE, + NULL_SENTINEL); + a->box = box == BOX_ASCII ? ascii_box_chars : unicode_box_chars; + + a->command_name = NULL; + a->title = xstrdup (""); + a->subtitle = xstrdup (""); + a->file_name = xstrdup (file_name); + a->file = NULL; + a->error = false; + a->page_number = 0; + a->lines = NULL; + a->allocated_lines = 0; + a->chart_cnt = 1; + + if (!update_page_size (a, true)) + goto error; + + return d; + +error: + output_driver_destroy (d); + return NULL; } static int -ascii_postopen_driver (struct outp_driver *this) +parse_page_size (struct driver_option *option) { - struct ascii_driver_ext *x = this->ext; - - assert (this->driver_open == 0); - - if (NULL == x->file.filename) - x->file.filename = xstrdup ("pspp.list"); - - x->w = x->page_width - x->left_margin - x->right_margin; - x->l = (x->page_length - (x->headers ? 3 : 0) - x->top_margin - - x->bottom_margin - 1); - if (x->w < 59 || x->l < 15) - { - msg (SE, _("ascii driver: Area of page excluding margins and headers " - "must be at least 59 characters wide by 15 lines long. Page as " - "configured is only %d characters by %d lines."), x->w, x->l); - return 0; - } - - this->res = x->lpi * x->cpi; - this->horiz = x->lpi; - this->vert = x->cpi; - this->width = x->w * this->horiz; - this->length = x->l * this->vert; - - if (ls_null_p (&x->ops[OPS_FORMFEED])) - ls_create (&x->ops[OPS_FORMFEED], "\f"); - if (ls_null_p (&x->ops[OPS_NEWLINE]) - || !strcmp (ls_c_str (&x->ops[OPS_NEWLINE]), "default")) + int dim = atol (option->default_value); + + if (option->value != NULL) { - ls_create (&x->ops[OPS_NEWLINE], "\n"); - x->file.mode = "wt"; + if (!strcmp (option->value, "auto")) + dim = -1; + else + { + int value; + char *tail; + + errno = 0; + value = strtol (option->value, &tail, 0); + if (dim >= 1 && errno != ERANGE && *tail == '\0') + dim = value; + else + msg (MW, _("%s: %s must be positive integer or `auto'"), + option->driver_name, option->name); + } } - - { - int i; - - for (i = 0; i < LNS_COUNT; i++) - { - char c[2]; - c[1] = 0; - if (!ls_null_p (&x->box[i])) - continue; - switch (i) - { - case TAYSTE2BYTE (0, 0, 0, 0): - c[0] = ' '; - break; - - case TAYSTE2BYTE (0, 1, 0, 0): - case TAYSTE2BYTE (0, 1, 0, 1): - case TAYSTE2BYTE (0, 0, 0, 1): - c[0] = '-'; - break; - - case TAYSTE2BYTE (1, 0, 0, 0): - case TAYSTE2BYTE (1, 0, 1, 0): - case TAYSTE2BYTE (0, 0, 1, 0): - c[0] = '|'; - break; - - case TAYSTE2BYTE (0, 3, 0, 0): - case TAYSTE2BYTE (0, 3, 0, 3): - case TAYSTE2BYTE (0, 0, 0, 3): - case TAYSTE2BYTE (0, 2, 0, 0): - case TAYSTE2BYTE (0, 2, 0, 2): - case TAYSTE2BYTE (0, 0, 0, 2): - c[0] = '='; - break; - - case TAYSTE2BYTE (3, 0, 0, 0): - case TAYSTE2BYTE (3, 0, 3, 0): - case TAYSTE2BYTE (0, 0, 3, 0): - case TAYSTE2BYTE (2, 0, 0, 0): - case TAYSTE2BYTE (2, 0, 2, 0): - case TAYSTE2BYTE (0, 0, 2, 0): - c[0] = '#'; - break; - - default: - if (BYTE2TAYSTE (i, LNS_LEFT) > 1 - || BYTE2TAYSTE (i, LNS_TOP) > 1 - || BYTE2TAYSTE (i, LNS_RIGHT) > 1 - || BYTE2TAYSTE (i, LNS_BOTTOM) > 1) - c[0] = '#'; - else - c[0] = '+'; - break; - } - ls_create (&x->box[i], c); - } - } - - { - int i; - - this->cp_x = this->cp_y = 0; - this->font_height = this->vert; - this->prop_em_width = this->horiz; - this->fixed_width = this->horiz; - - this->horiz_line_width[0] = 0; - this->vert_line_width[0] = 0; - - for (i = 1; i < OUTP_L_COUNT; i++) - { - this->horiz_line_width[i] = this->vert; - this->vert_line_width[i] = this->horiz; - } - - for (i = 0; i < (1 << OUTP_L_COUNT); i++) - { - this->horiz_line_spacing[i] = (i & ~1) ? this->vert : 0; - this->vert_line_spacing[i] = (i & ~1) ? this->horiz : 0; - } - } - - this->driver_open = 1; - msg (VM (2), _("%s: Initialization complete."), this->name); - - return 1; + + driver_option_destroy (option); + + return dim; } static int -ascii_close_driver (struct outp_driver *this) +vertical_margins (const struct ascii_driver *a) { - struct ascii_driver_ext *x = this->ext; - int i; - - assert (this->driver_open == 1); - msg (VM (2), _("%s: Beginning closing..."), this->name); - - x = this->ext; - for (i = 0; i < OPS_COUNT; i++) - ls_destroy (&x->ops[i]); - for (i = 0; i < LNS_COUNT; i++) - ls_destroy (&x->box[i]); - for (i = 0; i < FSTY_COUNT; i++) - ls_destroy (&x->fonts[i]); - if (x->lines != NULL) - { - int line; - - for (line = 0; line < x->lines_cap; line++) - free (x->lines[line].chars); - free (x->lines); - } - fn_close_ext (&x->file); - free (x->file.filename); - free (x); - - this->driver_open = 0; - msg (VM (3), _("%s: Finished closing."), this->name); - - return 1; + return a->top_margin + a->bottom_margin + (a->headers ? 3 : 0); } -/* Generic option types. */ -enum - { - pos_int_arg = -10, - nonneg_int_arg, - string_arg, - font_string_arg, - boolean_arg - }; - -static struct outp_option option_tab[] = - { - {"headers", boolean_arg, 0}, - {"output-file", 1, 0}, - {"char-set", 2, 0}, - {"length", pos_int_arg, 0}, - {"width", pos_int_arg, 1}, - {"lpi", pos_int_arg, 2}, - {"cpi", pos_int_arg, 3}, - {"init", string_arg, 0}, - {"done", string_arg, 1}, - {"left-margin", nonneg_int_arg, 0}, - {"right-margin", nonneg_int_arg, 1}, - {"top-margin", nonneg_int_arg, 2}, - {"bottom-margin", nonneg_int_arg, 3}, - {"paginate", boolean_arg, 1}, - {"form-feed-string", string_arg, 2}, - {"newline-string", string_arg, 3}, - {"italic-on", font_string_arg, 0}, - {"italic-off", font_string_arg, 1}, - {"bold-on", font_string_arg, 2}, - {"bold-off", font_string_arg, 3}, - {"bold-italic-on", font_string_arg, 4}, - {"bold-italic-off", font_string_arg, 5}, - {"overstrike-style", 3, 0}, - {"tab-width", nonneg_int_arg, 4}, - {"carriage-return-style", 4, 0}, - {"squeeze", boolean_arg, 2}, - {"", 0, 0}, - }; - -static void -ascii_option (struct outp_driver *this, const char *key, - const struct string *val) +/* Re-calculates the page width and length based on settings, + margins, and, if "auto" is set, the size of the user's + terminal window or GUI output window. */ +static bool +update_page_size (struct ascii_driver *a, bool issue_error) { - struct ascii_driver_ext *x = this->ext; - int cat, subcat; - const char *value; + enum { MIN_WIDTH = 6, MIN_LENGTH = 6 }; - value = ds_c_str (val); - if (!strncmp (key, "box[", 4)) - { - char *tail; - int indx = strtol (&key[4], &tail, 4); - if (*tail != ']' || indx < 0 || indx > LNS_COUNT) - { - msg (SE, _("Bad index value for `box' key: syntax is box[INDEX], " - "0 <= INDEX < %d decimal, with INDEX expressed in base 4."), - LNS_COUNT); - return; - } - if (!ls_null_p (&x->box[indx])) - msg (SW, _("Duplicate value for key `%s'."), key); - ls_create (&x->box[indx], value); - return; - } + if (a->auto_width) + a->width = settings_get_viewwidth (); + if (a->auto_length) + a->length = settings_get_viewlength () - vertical_margins (a); - cat = outp_match_keyword (key, option_tab, option_info, &subcat); - switch (cat) + if (a->width < MIN_WIDTH || a->length < MIN_LENGTH) { - case 0: - msg (SE, _("Unknown configuration parameter `%s' for ascii device driver."), - key); - break; - case 1: - free (x->file.filename); - x->file.filename = xstrdup (value); - break; - case 2: - if (!strcmp (value, "ascii")) - x->char_set = CHS_ASCII; - else if (!strcmp (value, "latin1")) - x->char_set = CHS_LATIN1; - else - msg (SE, _("Unknown character set `%s'. Valid character sets are " - "`ascii' and `latin1'."), value); - break; - case 3: - if (!strcmp (value, "single")) - x->overstrike_style = OVS_SINGLE; - else if (!strcmp (value, "line")) - x->overstrike_style = OVS_LINE; - else - msg (SE, _("Unknown overstrike style `%s'. Valid overstrike styles " - "are `single' and `line'."), value); - break; - case 4: - if (!strcmp (value, "bs")) - x->carriage_return_style = CRS_BS; - else if (!strcmp (value, "cr")) - x->carriage_return_style = CRS_CR; - else - msg (SE, _("Unknown carriage return style `%s'. Valid carriage " - "return styles are `cr' and `bs'."), value); - break; - case pos_int_arg: - { - char *tail; - int arg; - - errno = 0; - arg = strtol (value, &tail, 0); - if (arg < 1 || errno == ERANGE || *tail) - { - msg (SE, _("Positive integer required as value for `%s'."), key); - break; - } - switch (subcat) - { - case 0: - x->page_length = arg; - break; - case 1: - x->page_width = arg; - break; - case 2: - x->lpi = arg; - break; - case 3: - x->cpi = arg; - break; - default: - assert (0); - } - } - break; - case nonneg_int_arg: - { - char *tail; - int arg; - - errno = 0; - arg = strtol (value, &tail, 0); - if (arg < 0 || errno == ERANGE || *tail) - { - msg (SE, _("Zero or positive integer required as value for `%s'."), - key); - break; - } - switch (subcat) - { - case 0: - x->left_margin = arg; - break; - case 1: - x->right_margin = arg; - break; - case 2: - x->top_margin = arg; - break; - case 3: - x->bottom_margin = arg; - break; - case 4: - x->tab_width = arg; - break; - default: - assert (0); - } - } - break; - case string_arg: - { - struct fixed_string *s; - switch (subcat) - { - case 0: - s = &x->ops[OPS_INIT]; - break; - case 1: - s = &x->ops[OPS_DONE]; - break; - case 2: - s = &x->ops[OPS_FORMFEED]; - break; - case 3: - s = &x->ops[OPS_NEWLINE]; - break; - default: - assert (0); - abort (); - } - ls_create (s, value); - } - break; - case font_string_arg: - { - if (!strcmp (value, "overstrike")) - { - ls_destroy (&x->fonts[subcat]); - return; - } - ls_create (&x->fonts[subcat], value); - } - break; - case boolean_arg: - { - int setting; - if (!strcmp (value, "on") || !strcmp (value, "true") - || !strcmp (value, "yes") || atoi (value)) - setting = 1; - else if (!strcmp (value, "off") || !strcmp (value, "false") - || !strcmp (value, "no") || !strcmp (value, "0")) - setting = 0; - else - { - msg (SE, _("Boolean value expected for %s."), key); - return; - } - switch (subcat) - { - case 0: - x->headers = setting; - break; - case 1: - x->paginate = setting; - break; - case 2: - x->squeeze_blank_lines = setting; - break; - default: - assert (0); - } - } - break; - default: - assert (0); + if (issue_error) + msg (ME, + _("ascii: page excluding margins and headers " + "must be at least %d characters wide by %d lines long, but " + "as configured is only %d characters by %d lines"), + MIN_WIDTH, MIN_LENGTH, + a->width, a->length); + if (a->width < MIN_WIDTH) + a->width = MIN_WIDTH; + if (a->length < MIN_LENGTH) + a->length = MIN_LENGTH; + return false; } + + reallocate_lines (a); + + return true; } -int -postopen (struct file_ext *f) +static void +ascii_destroy (struct output_driver *driver) { - struct ascii_driver_ext *x = f->param; - struct fixed_string *s = &x->ops[OPS_INIT]; + struct ascii_driver *a = ascii_driver_cast (driver); + int i; - if (!ls_empty_p (s) && fwrite (ls_c_str (s), ls_length (s), 1, f->file) < 1) - { - msg (ME, _("ASCII output driver: %s: %s"), - f->filename, strerror (errno)); - return 0; - } - return 1; + if (a->y > 0) + ascii_close_page (a); + + if (a->file != NULL) + fn_close (a->file_name, a->file); + free (a->command_name); + free (a->title); + free (a->subtitle); + free (a->file_name); + free (a->chart_file_name); + for (i = 0; i < a->allocated_lines; i++) + u8_line_destroy (&a->lines[i]); + free (a->lines); + free (a); } -int -preclose (struct file_ext *f) +static void +ascii_flush (struct output_driver *driver) { - struct ascii_driver_ext *x = f->param; - struct fixed_string *d = &x->ops[OPS_DONE]; - - if (!ls_empty_p (d) && fwrite (ls_c_str (d), ls_length (d), 1, f->file) < 1) + struct ascii_driver *a = ascii_driver_cast (driver); + if (a->y > 0) { - msg (ME, _("ASCII output driver: %s: %s"), - f->filename, strerror (errno)); - return 0; + ascii_close_page (a); + + if (fn_close (a->file_name, a->file) != 0) + msg_error (errno, _("ascii: closing output file `%s'"), a->file_name); + a->file = NULL; } - return 1; } -static int -ascii_open_page (struct outp_driver *this) +static void +ascii_output_table_item (struct ascii_driver *a, + const struct table_item *table_item) { - struct ascii_driver_ext *x = this->ext; + struct render_params params; + struct render_pager *p; int i; - assert (this->driver_open && !this->page_open); - x->page_number++; - if (!fn_open_ext (&x->file)) + update_page_size (a, false); + + params.draw_line = ascii_draw_line; + params.measure_cell_width = ascii_measure_cell_width; + params.measure_cell_height = ascii_measure_cell_height; + params.adjust_break = NULL; + params.draw_cell = ascii_draw_cell; + params.aux = a; + params.size[H] = a->width; + params.size[V] = a->length; + params.font_size[H] = 1; + params.font_size[V] = 1; + for (i = 0; i < RENDER_N_LINES; i++) { - msg (ME, _("ASCII output driver: %s: %s"), x->file.filename, - strerror (errno)); - return 0; + int width = i == RENDER_LINE_NONE ? 0 : 1; + params.line_widths[H][i] = width; + params.line_widths[V][i] = width; } + for (i = 0; i < TABLE_N_AXES; i++) + params.min_break[i] = a->min_break[i]; - if (x->l > x->lines_cap) + if (a->file == NULL && !ascii_open_page (a)) + return; + + p = render_pager_create (¶ms, table_item); + while (render_pager_has_next (p)) { - x->lines = xnrealloc (x->lines, x->l, sizeof *x->lines); - for (i = x->lines_cap; i < x->l; i++) + int used; + + if (a->y > 0) + a->y++; + used = render_pager_draw_next (p, a->length - a->y); + if (used == 0) { - struct line *line = &x->lines[i]; - line->chars = NULL; - line->char_cap = 0; + assert (a->y > 0); + ascii_close_page (a); + if (!ascii_open_page (a)) + break; } - x->lines_cap = x->l; + else + a->y += used; } - - for (i = 0; i < x->l; i++) - x->lines[i].char_cnt = 0; - - this->page_open = 1; - return 1; + render_pager_destroy (p); } -/* Ensures that at least the first L characters of line I in the - driver identified by struct ascii_driver_ext *X have been cleared out. */ -static inline void -expand_line (struct ascii_driver_ext *x, int i, int l) +static void +ascii_output_text (struct ascii_driver *a, const char *text) { - struct line *line; - int j; + struct table_item *table_item; - assert (i < x->lines_cap); - line = &x->lines[i]; - if (l > line->char_cap) - { - line->char_cap = l * 2; - line->chars = xnrealloc (line->chars, - line->char_cap, sizeof *line->chars); - } - for (j = line->char_cnt; j < l; j++) - line->chars[j] = ' '; - line->char_cnt = l; + table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL); + ascii_output_table_item (a, table_item); + table_item_unref (table_item); } -/* Puts line L at (H,K) in the current output page. Assumes - struct ascii_driver_ext named `ext'. */ -#define draw_line(H, K, L) \ - ext->lines[K].chars[H] = (L) | 0x800 - -/* Line styles for each position. */ -#define T(STYLE) (STYLE<ext; - int x1 = r->x1 / this->horiz; - int x2 = r->x2 / this->horiz; - int y1 = r->y1 / this->vert; - int x; + struct ascii_driver *a = ascii_driver_cast (driver); - assert (this->driver_open && this->page_open); - if (x1 == x2) + output_driver_track_current_command (output_item, &a->command_name); + + if (a->error) return; -#if DEBUGGING - if (x1 > x2 - || x1 < 0 || x1 >= ext->w - || x2 <= 0 || x2 > ext->w - || y1 < 0 || y1 >= ext->l) - { -#if !SUPPRESS_WARNINGS - printf (_("ascii_line_horz: bad hline (%d,%d),%d out of (%d,%d)\n"), - x1, x2, y1, ext->w, ext->l); -#endif - return; - } -#endif - if (ext->lines[y1].char_cnt < x2) - expand_line (ext, y1, x2); + if (is_table_item (output_item)) + ascii_output_table_item (a, to_table_item (output_item)); +#ifdef HAVE_CAIRO + else if (is_chart_item (output_item) && a->chart_file_name != NULL) + { + struct chart_item *chart_item = to_chart_item (output_item); + char *file_name; + + file_name = xr_draw_png_chart (chart_item, a->chart_file_name, + a->chart_cnt++, + &a->fg, + &a->bg); + if (file_name != NULL) + { + struct text_item *text_item; - for (x = x1; x < x2; x++) - draw_line (x, y1, (style << LNS_LEFT) | (style << LNS_RIGHT)); -} + text_item = text_item_create_format ( + TEXT_ITEM_PARAGRAPH, _("See %s for a chart."), file_name); -static void -ascii_line_vert (struct outp_driver *this, const struct rect *r, - const struct color *c UNUSED, int style) -{ - struct ascii_driver_ext *ext = this->ext; - int x1 = r->x1 / this->horiz; - int y1 = r->y1 / this->vert; - int y2 = r->y2 / this->vert; - int y; + ascii_submit (driver, &text_item->output_item); + text_item_unref (text_item); + free (file_name); + } + } +#endif /* HAVE_CAIRO */ + else if (is_text_item (output_item)) + { + const struct text_item *text_item = to_text_item (output_item); + enum text_item_type type = text_item_get_type (text_item); + const char *text = text_item_get_text (text_item); - assert (this->driver_open && this->page_open); - if (y1 == y2) - return; -#if DEBUGGING - if (y1 > y2 - || x1 < 0 || x1 >= ext->w - || y1 < 0 || y1 >= ext->l - || y2 < 0 || y2 > ext->l) + switch (type) + { + case TEXT_ITEM_TITLE: + free (a->title); + a->title = xstrdup (text); + break; + + case TEXT_ITEM_SUBTITLE: + free (a->subtitle); + a->subtitle = xstrdup (text); + break; + + case TEXT_ITEM_COMMAND_OPEN: + case TEXT_ITEM_COMMAND_CLOSE: + break; + + case TEXT_ITEM_BLANK_LINE: + if (a->y > 0) + a->y++; + break; + + case TEXT_ITEM_EJECT_PAGE: + if (a->y > 0) + ascii_close_page (a); + break; + + default: + ascii_output_text (a, text); + break; + } + } + else if (is_message_item (output_item)) { -#if !SUPPRESS_WARNINGS - printf (_("ascii_line_vert: bad vline %d,(%d,%d) out of (%d,%d)\n"), - x1, y1, y2, ext->w, ext->l); -#endif - return; + const struct message_item *message_item = to_message_item (output_item); + const struct msg *msg = message_item_get_msg (message_item); + char *s = msg_to_string (msg, a->command_name); + ascii_output_text (a, s); + free (s); } -#endif +} - for (y = y1; y < y2; y++) - if (ext->lines[y].char_cnt <= x1) - expand_line (ext, y, x1 + 1); +const struct output_driver_factory txt_driver_factory = + { "txt", "-", ascii_create }; +const struct output_driver_factory list_driver_factory = + { "list", "-", ascii_create }; - for (y = y1; y < y2; y++) - draw_line (x1, y, (style << LNS_TOP) | (style << LNS_BOTTOM)); -} +static const struct output_driver_class ascii_driver_class = + { + "text", + ascii_destroy, + ascii_submit, + ascii_flush, + }; + +static char *ascii_reserve (struct ascii_driver *, int y, int x0, int x1, + int n); +static void ascii_layout_cell (struct ascii_driver *, + const struct table_cell *, + int bb[TABLE_N_AXES][2], + int clip[TABLE_N_AXES][2], + int *width, int *height); static void -ascii_line_intersection (struct outp_driver *this, const struct rect *r, - const struct color *c UNUSED, - const struct outp_styles *style) +ascii_draw_line (void *a_, int bb[TABLE_N_AXES][2], + enum render_line_style styles[TABLE_N_AXES][2]) { - struct ascii_driver_ext *ext = this->ext; - int x = r->x1 / this->horiz; - int y = r->y1 / this->vert; - int l; - - assert (this->driver_open && this->page_open); -#if DEBUGGING - if (x < 0 || x >= ext->w || y < 0 || y >= ext->l) + struct ascii_driver *a = a_; + char mbchar[6]; + int x0, y0, x1, y1; + ucs4_t uc; + int mblen; + int x, y; + + /* Clip to the page. */ + x0 = MAX (bb[H][0] + a->x, 0); + y0 = MAX (bb[V][0] + a->y, 0); + x1 = MIN (bb[H][1] + a->x, a->width); + y1 = MIN (bb[V][1] + a->y, a->length); + if (x1 <= 0 || y1 <= 0 || x0 >= a->width || y0 >= a->length) + return; + + /* Draw. */ + uc = a->box[make_box_index (styles[V][0], styles[V][1], + styles[H][0], styles[H][1])]; + mblen = u8_uctomb (CHAR_CAST (uint8_t *, mbchar), uc, 6); + for (y = y0; y < y1; y++) { -#if !SUPPRESS_WARNINGS - printf (_("ascii_line_intersection: bad intsct (%d,%d) out of (%d,%d)\n"), - x, y, ext->w, ext->l); -#endif - return; + char *p = ascii_reserve (a, y, x0, x1, mblen * (x1 - x0)); + for (x = x0; x < x1; x++) + { + memcpy (p, mbchar, mblen); + p += mblen; + } } -#endif - - l = ((style->l << LNS_LEFT) | (style->r << LNS_RIGHT) - | (style->t << LNS_TOP) | (style->b << LNS_BOTTOM)); - - if (ext->lines[y].char_cnt <= x) - expand_line (ext, y, x + 1); - draw_line (x, y, l); } -/* FIXME: Later we could set this up so that for certain devices it - performs shading? */ static void -ascii_box (struct outp_driver *this UNUSED, const struct rect *r UNUSED, - const struct color *bord UNUSED, const struct color *fill UNUSED) +ascii_measure_cell_width (void *a_, const struct table_cell *cell, + int *min_width, int *max_width) { - assert (this->driver_open && this->page_open); + struct ascii_driver *a = a_; + int bb[TABLE_N_AXES][2]; + int clip[TABLE_N_AXES][2]; + int h; + + bb[H][0] = 0; + bb[H][1] = INT_MAX; + bb[V][0] = 0; + bb[V][1] = INT_MAX; + clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0; + ascii_layout_cell (a, cell, bb, clip, max_width, &h); + + if (cell->n_contents != 1 + || cell->contents[0].table + || strchr (cell->contents[0].text, ' ')) + { + bb[H][1] = 1; + ascii_layout_cell (a, cell, bb, clip, min_width, &h); + } + else + *min_width = *max_width; } -/* Polylines not supported. */ -static void -ascii_polyline_begin (struct outp_driver *this UNUSED, const struct color *c UNUSED) -{ - assert (this->driver_open && this->page_open); -} -static void -ascii_polyline_point (struct outp_driver *this UNUSED, int x UNUSED, int y UNUSED) -{ - assert (this->driver_open && this->page_open); -} -static void -ascii_polyline_end (struct outp_driver *this UNUSED) +static int +ascii_measure_cell_height (void *a_, const struct table_cell *cell, int width) { - assert (this->driver_open && this->page_open); + struct ascii_driver *a = a_; + int bb[TABLE_N_AXES][2]; + int clip[TABLE_N_AXES][2]; + int w, h; + + bb[H][0] = 0; + bb[H][1] = width; + bb[V][0] = 0; + bb[V][1] = INT_MAX; + clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0; + ascii_layout_cell (a, cell, bb, clip, &w, &h); + return h; } static void -ascii_text_set_font_by_name (struct outp_driver * this, const char *s) +ascii_draw_cell (void *a_, const struct table_cell *cell, + int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2]) { - struct ascii_driver_ext *x = this->ext; - int len = strlen (s); + struct ascii_driver *a = a_; + int w, h; - assert (this->driver_open && this->page_open); - x->cur_font = OUTP_F_R; - if (len == 0) - return; - if (s[len - 1] == 'I') - { - if (len > 1 && s[len - 2] == 'B') - x->cur_font = OUTP_F_BI; - else - x->cur_font = OUTP_F_I; - } - else if (s[len - 1] == 'B') - x->cur_font = OUTP_F_B; + ascii_layout_cell (a, cell, bb, clip, &w, &h); } -static void -ascii_text_set_font_by_position (struct outp_driver *this, int pos) +static char * +ascii_reserve (struct ascii_driver *a, int y, int x0, int x1, int n) { - struct ascii_driver_ext *x = this->ext; - assert (this->driver_open && this->page_open); - x->cur_font = pos >= 0 && pos < 4 ? pos : 0; + assert (y < a->allocated_lines); + return u8_line_reserve (&a->lines[y], x0, x1, n); } static void -ascii_text_set_font_by_family (struct outp_driver *this UNUSED, const char *s UNUSED) +text_draw (struct ascii_driver *a, unsigned int options, + int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2], + int y, const uint8_t *string, int n, size_t width) { - assert (this->driver_open && this->page_open); -} + int x0 = MAX (0, clip[H][0] + a->x); + int y0 = MAX (0, clip[V][0] + a->y); + int x1 = MIN (a->width, clip[H][1] + a->x); + int y1 = MIN (a->length, clip[V][1] + a->y); + int x; -static const char * -ascii_text_get_font_name (struct outp_driver *this) -{ - struct ascii_driver_ext *x = this->ext; + y += a->y; + if (y < y0 || y >= y1) + return; - assert (this->driver_open && this->page_open); - switch (x->cur_font) + switch (options & TAB_ALIGNMENT) { - case OUTP_F_R: - return "R"; - case OUTP_F_I: - return "I"; - case OUTP_F_B: - return "B"; - case OUTP_F_BI: - return "BI"; + case TAB_LEFT: + x = bb[H][0]; + break; + case TAB_CENTER: + x = (bb[H][0] + bb[H][1] - width + 1) / 2; + break; + case TAB_RIGHT: + x = bb[H][1] - width; + break; default: - assert (0); + NOT_REACHED (); } - abort (); -} - -static const char * -ascii_text_get_font_family (struct outp_driver *this UNUSED) -{ - assert (this->driver_open && this->page_open); - return ""; -} - -static int -ascii_text_set_size (struct outp_driver *this, int size) -{ - assert (this->driver_open && this->page_open); - return size == this->vert; -} - -static int -ascii_text_get_size (struct outp_driver *this, int *em_width) -{ - assert (this->driver_open && this->page_open); - if (em_width) - *em_width = this->horiz; - return this->vert; -} - -static void text_draw (struct outp_driver *this, struct outp_text *t); - -/* Divides the text T->S into lines of width T->H. Sets T->V to the - number of lines necessary. Actually draws the text if DRAW is - nonzero. - - You probably don't want to look at this code. */ -static void -delineate (struct outp_driver *this, struct outp_text *t, int draw) -{ - /* Width we're fitting everything into. */ - int width = t->h / this->horiz; + x += a->x; + if (x >= x1) + return; - /* Maximum `y' position we can write to. */ - int max_y; + while (x < x0) + { + ucs4_t uc; + int mblen; + int w; - /* Current position in string, character following end of string. */ - const char *s = ls_c_str (&t->s); - const char *end = ls_end (&t->s); + if (n == 0) + return; + mblen = u8_mbtouc (&uc, string, n); - /* Temporary struct outp_text to pass to low-level function. */ - struct outp_text temp; + string += mblen; + n -= mblen; -#if DEBUGGING && 0 - if (!ext->debug) - { - ext->debug = 1; - printf (_("%s: horiz=%d, vert=%d\n"), this->name, this->horiz, this->vert); + w = uc_width (uc, "UTF-8"); + if (w > 0) + { + x += w; + width -= w; + } } -#endif + if (n == 0) + return; - if (!width) + if (x + width > x1) { - t->h = t->v = 0; - return; - } + int ofs; - if (draw) - { - temp.options = t->options; - ls_shallow_copy (&temp.s, &t->s); - temp.h = t->h / this->horiz; - temp.x = t->x / this->horiz; + ofs = width = 0; + for (ofs = 0; ofs < n; ) + { + ucs4_t uc; + int mblen; + int w; + + mblen = u8_mbtouc (&uc, string + ofs, n - ofs); + + w = uc_width (uc, "UTF-8"); + if (w > 0) + { + if (width + w > x1 - x) + break; + width += w; + } + ofs += mblen; + } + n = ofs; + if (n == 0) + return; } - else - t->y = 0; - temp.y = t->y / this->vert; - if (t->options & OUTP_T_VERT) - max_y = (t->v / this->vert) + temp.y - 1; + if (!(options & TAB_EMPH) || a->emphasis == EMPH_NONE) + memcpy (ascii_reserve (a, y, x, x + width, n), string, n); else - max_y = INT_MAX; - - while (end - s > width) { - const char *beg = s; - const char *space; - - /* Find first space before &s[width]. */ - space = &s[width]; - for (;;) - { - if (space > s) - { - if (!isspace ((unsigned char) space[-1])) - { - space--; - continue; - } - else - s = space; - } - else - s = space = &s[width]; - break; - } + size_t n_out; + size_t ofs; + char *out; + int mblen; + + /* First figure out how many bytes need to be inserted. */ + n_out = n; + for (ofs = 0; ofs < n; ofs += mblen) + { + ucs4_t uc; + int w; - /* Draw text. */ - if (draw) - { - ls_init (&temp.s, beg, space - beg); - temp.w = space - beg; - text_draw (this, &temp); - } - if (++temp.y > max_y) - return; - - /* Find first nonspace after space. */ - while (s < end && isspace ((unsigned char) *s)) - s++; - } - if (s < end) - { - if (draw) - { - ls_init (&temp.s, s, end - s); - temp.w = end - s; - text_draw (this, &temp); - } - temp.y++; - } + mblen = u8_mbtouc (&uc, string + ofs, n - ofs); + w = uc_width (uc, "UTF-8"); - t->v = (temp.y * this->vert) - t->y; -} + if (w > 0) + n_out += a->emphasis == EMPH_UNDERLINE ? 2 : 1 + mblen; + } -static void -ascii_text_metrics (struct outp_driver *this, struct outp_text *t) -{ - assert (this->driver_open && this->page_open); - if (!(t->options & OUTP_T_HORZ)) - { - t->v = this->vert; - t->h = ls_length (&t->s) * this->horiz; + /* Then insert them. */ + out = ascii_reserve (a, y, x, x + width, n_out); + for (ofs = 0; ofs < n; ofs += mblen) + { + ucs4_t uc; + int w; + + mblen = u8_mbtouc (&uc, string + ofs, n - ofs); + w = uc_width (uc, "UTF-8"); + + if (w > 0) + { + if (a->emphasis == EMPH_UNDERLINE) + *out++ = '_'; + else + out = mempcpy (out, string + ofs, mblen); + *out++ = '\b'; + } + out = mempcpy (out, string + ofs, mblen); + } } - else - delineate (this, t, 0); } -static void -ascii_text_draw (struct outp_driver *this, struct outp_text *t) +static int +ascii_layout_cell_text (struct ascii_driver *a, + const struct cell_contents *contents, + int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2], + int *widthp) { - /* FIXME: orientations not supported. */ - assert (this->driver_open && this->page_open); - if (!(t->options & OUTP_T_HORZ)) - { - struct outp_text temp; - - temp.options = t->options; - temp.s = t->s; - temp.h = temp.v = 0; - temp.x = t->x / this->horiz; - temp.y = t->y / this->vert; - text_draw (this, &temp); - ascii_text_metrics (this, t); - - return; - } - delineate (this, t, 1); -} + size_t length = strlen (contents->text); + char *breaks; + int bb_width; + size_t pos; + int y; -static void -text_draw (struct outp_driver *this, struct outp_text *t) -{ - struct ascii_driver_ext *ext = this->ext; - unsigned attr = ext->cur_font << 8; + y = bb[V][0]; + if (length == 0) + return y; - int x = t->x; - int y = t->y; + breaks = xmalloc (length + 1); + u8_possible_linebreaks (CHAR_CAST (const uint8_t *, contents->text), length, + "UTF-8", breaks); + breaks[length] = (breaks[length - 1] == UC_BREAK_MANDATORY + ? UC_BREAK_PROHIBITED : UC_BREAK_POSSIBLE); - char *s = ls_c_str (&t->s); + pos = 0; + bb_width = bb[H][1] - bb[H][0]; + for (y = bb[V][0]; y < bb[V][1] && pos < length; y++) + { + const uint8_t *line = CHAR_CAST (const uint8_t *, contents->text + pos); + const char *b = breaks + pos; + size_t n = length - pos; - /* Expand the line with the assumption that S takes up LEN character - spaces (sometimes it takes up less). */ - int min_len; + size_t last_break_ofs = 0; + int last_break_width = 0; + int width = 0; + size_t graph_ofs; + size_t ofs; - assert (this->driver_open && this->page_open); - switch (t->options & OUTP_T_JUST_MASK) - { - case OUTP_T_JUST_LEFT: - break; - case OUTP_T_JUST_CENTER: - x -= (t->h - t->w) / 2; /* fall through */ - case OUTP_T_JUST_RIGHT: - x += (t->h - t->w); - break; - default: - assert (0); - } + for (ofs = 0; ofs < n; ) + { + ucs4_t uc; + int mblen; + int w; - if (!(t->y < ext->l && x < ext->w)) - return; - min_len = min (x + ls_length (&t->s), ext->w); - if (ext->lines[t->y].char_cnt < min_len) - expand_line (ext, t->y, min_len); + mblen = u8_mbtouc (&uc, line + ofs, n - ofs); + if (b[ofs] == UC_BREAK_MANDATORY) + break; + else if (b[ofs] == UC_BREAK_POSSIBLE) + { + last_break_ofs = ofs; + last_break_width = width; + } + + w = uc_width (uc, "UTF-8"); + if (w > 0) + { + if (width + w > bb_width) + { + if (isspace (line[ofs])) + break; + else if (last_break_ofs != 0) + { + ofs = last_break_ofs; + width = last_break_width; + break; + } + } + width += w; + } + ofs += mblen; + } - { - int len = ls_length (&t->s); + /* Trim any trailing spaces off the end of the text to be drawn. */ + for (graph_ofs = ofs; graph_ofs > 0; graph_ofs--) + if (!isspace (line[graph_ofs - 1])) + break; + width -= ofs - graph_ofs; - if (len + x > ext->w) - len = ext->w - x; - while (len--) - ext->lines[y].chars[x++] = *s++ | attr; - } -} - -/* ascii_close_page () and support routines. */ + /* Draw text. */ + text_draw (a, contents->options, bb, clip, y, line, graph_ofs, width); -#define LINE_BUF_SIZE 1024 -static char *line_buf; -static char *line_p; + /* If a new-line ended the line, just skip the new-line. Otherwise, skip + past any spaces past the end of the line (but not past a new-line). */ + if (b[ofs] == UC_BREAK_MANDATORY) + ofs++; + else + while (ofs < n && isspace (line[ofs]) && b[ofs] != UC_BREAK_MANDATORY) + ofs++; -static inline int -commit_line_buf (struct outp_driver *this) -{ - struct ascii_driver_ext *x = this->ext; - - if ((int) fwrite (line_buf, 1, line_p - line_buf, x->file.file) - < line_p - line_buf) - { - msg (ME, _("Writing `%s': %s"), x->file.filename, strerror (errno)); - return 0; + if (width > *widthp) + *widthp = width; + pos += ofs; } - line_p = line_buf; - return 1; + free (breaks); + + return y; } -/* Writes everything from BP to EP exclusive into line_buf, or to - THIS->output if line_buf overflows. */ -static inline void -output_string (struct outp_driver *this, const char *bp, const char *ep) +static int +ascii_layout_subtable (struct ascii_driver *a, + const struct cell_contents *contents, + int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2] UNUSED, + int *widthp) { - if (LINE_BUF_SIZE - (line_p - line_buf) >= ep - bp) + struct render_params params; + struct render_pager *p; + int r[TABLE_N_AXES][2]; + int width, height; + int i; + + params.draw_line = ascii_draw_line; + params.measure_cell_width = ascii_measure_cell_width; + params.measure_cell_height = ascii_measure_cell_height; + params.adjust_break = NULL; + params.draw_cell = ascii_draw_cell, + params.aux = a; + params.size[H] = bb[TABLE_HORZ][1] - bb[TABLE_HORZ][0]; + params.size[V] = bb[TABLE_VERT][1] - bb[TABLE_VERT][0]; + params.font_size[H] = 1; + params.font_size[V] = 1; + for (i = 0; i < RENDER_N_LINES; i++) { - memcpy (line_p, bp, ep - bp); - line_p += ep - bp; + int width = i == RENDER_LINE_NONE ? 0 : 1; + params.line_widths[H][i] = width; + params.line_widths[V][i] = width; } - else - while (bp < ep) - { - if (LINE_BUF_SIZE - (line_p - line_buf) <= 1 && !commit_line_buf (this)) - return; - *line_p++ = *bp++; - } -} -/* Writes everything from BP to EP exclusive into line_buf, or to - THIS->output if line_buf overflows. Returns 1 if additional passes - over the line are required. FIXME: probably could do a lot of - optimization here. */ -static inline int -output_shorts (struct outp_driver *this, - const unsigned short *bp, const unsigned short *ep) -{ - struct ascii_driver_ext *ext = this->ext; - size_t remaining = LINE_BUF_SIZE - (line_p - line_buf); - int result = 0; + p = render_pager_create (¶ms, contents->table); + width = render_pager_get_size (p, TABLE_HORZ); + height = render_pager_get_size (p, TABLE_VERT); - for (; bp < ep; bp++) + /* r = intersect(bb, clip) - bb. */ + for (i = 0; i < TABLE_N_AXES; i++) { - if (*bp & 0x800) - { - struct fixed_string *box = &ext->box[*bp & 0xff]; - size_t len = ls_length (box); + r[i][0] = MAX (bb[i][0], clip[i][0]) - bb[i][0]; + r[i][1] = MIN (bb[i][1], clip[i][1]) - bb[i][0]; + } - if (remaining >= len) - { - memcpy (line_p, ls_c_str (box), len); - line_p += len; - remaining -= len; - } - else - { - if (!commit_line_buf (this)) - return 0; - output_string (this, ls_c_str (box), ls_end (box)); - remaining = LINE_BUF_SIZE - (line_p - line_buf); - } - } - else if (*bp & 0x0300) - { - struct fixed_string *on; - char buf[5]; - int len; - - switch (*bp & 0x0300) - { - case OUTP_F_I << 8: - on = &ext->fonts[FSTY_ON | FSTY_ITALIC]; - break; - case OUTP_F_B << 8: - on = &ext->fonts[FSTY_ON | FSTY_BOLD]; - break; - case OUTP_F_BI << 8: - on = &ext->fonts[FSTY_ON | FSTY_BOLD_ITALIC]; - break; - default: - assert (0); - abort (); - } - if (!on) - { - if (ext->overstrike_style == OVS_SINGLE) - switch (*bp & 0x0300) - { - case OUTP_F_I << 8: - buf[0] = '_'; - buf[1] = '\b'; - buf[2] = *bp; - len = 3; - break; - case OUTP_F_B << 8: - buf[0] = *bp; - buf[1] = '\b'; - buf[2] = *bp; - len = 3; - break; - case OUTP_F_BI << 8: - buf[0] = '_'; - buf[1] = '\b'; - buf[2] = *bp; - buf[3] = '\b'; - buf[4] = *bp; - len = 5; - break; - default: - assert (0); - abort (); - } - else - { - buf[0] = *bp; - result = len = 1; - } - } - else - { - buf[0] = *bp; - len = 1; - } - output_string (this, buf, &buf[len]); - } - else if (remaining) - { - *line_p++ = *bp; - remaining--; - } - else - { - if (!commit_line_buf (this)) - return 0; - remaining = LINE_BUF_SIZE - (line_p - line_buf); - *line_p++ = *bp; - } + if (r[H][0] < r[H][1] && r[V][0] < r[V][1]) + { + unsigned int alignment = contents->options & TAB_ALIGNMENT; + int save_x = a->x; + + a->x += bb[TABLE_HORZ][0]; + if (alignment == TAB_RIGHT) + a->x += params.size[H] - width; + else if (alignment == TAB_CENTER) + a->x += (params.size[H] - width) / 2; + a->y += bb[TABLE_VERT][0]; + render_pager_draw (p); + a->y -= bb[TABLE_VERT][0]; + a->x = save_x; } + render_pager_destroy (p); - return result; + if (width > *widthp) + *widthp = width; + return bb[V][0] + height; } -/* Writes CH into line_buf N times, or to THIS->output if line_buf - overflows. */ -static inline void -output_char (struct outp_driver *this, int n, char ch) +static void +ascii_layout_cell (struct ascii_driver *a, const struct table_cell *cell, + int bb_[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2], + int *widthp, int *heightp) { - if (LINE_BUF_SIZE - (line_p - line_buf) >= n) + int bb[TABLE_N_AXES][2]; + size_t i; + + *widthp = 0; + *heightp = 0; + + memcpy (bb, bb_, sizeof bb); + for (i = 0; i < cell->n_contents && bb[V][0] < bb[V][1]; i++) { - memset (line_p, ch, n); - line_p += n; + const struct cell_contents *contents = &cell->contents[i]; + + /* Put a blank line between contents. */ + if (i > 0) + { + bb[V][0]++; + if (bb[V][0] >= bb[V][1]) + break; + } + + if (contents->text) + bb[V][0] = ascii_layout_cell_text (a, contents, bb, clip, widthp); + else + bb[V][0] = ascii_layout_subtable (a, contents, bb, clip, widthp); } - else - while (n--) - { - if (LINE_BUF_SIZE - (line_p - line_buf) <= 1 && !commit_line_buf (this)) - return; - *line_p++ = ch; - } + *heightp = bb[V][0] - bb_[V][0]; } -/* Advance the carriage from column 0 to the left margin. */ -static void -advance_to_left_margin (struct outp_driver *this) +void +ascii_test_write (struct output_driver *driver, + const char *s, int x, int y, unsigned int options) { - struct ascii_driver_ext *ext = this->ext; - int margin; + struct ascii_driver *a = ascii_driver_cast (driver); + struct cell_contents contents; + struct table_cell cell; + int bb[TABLE_N_AXES][2]; + int width, height; - margin = ext->left_margin; - if (margin == 0) + if (a->file == NULL && !ascii_open_page (a)) return; - if (ext->tab_width && margin >= ext->tab_width) - { - output_char (this, margin / ext->tab_width, '\t'); - margin %= ext->tab_width; - } - if (margin) - output_char (this, margin, ' '); + a->y = 0; + + contents.options = options | TAB_LEFT; + contents.text = CONST_CAST (char *, s); + contents.table = NULL; + + memset (&cell, 0, sizeof cell); + cell.contents = &contents; + cell.n_contents = 1; + + bb[TABLE_HORZ][0] = x; + bb[TABLE_HORZ][1] = a->width; + bb[TABLE_VERT][0] = y; + bb[TABLE_VERT][1] = a->length; + + ascii_layout_cell (a, &cell, bb, bb, &width, &height); + + a->y = 1; } -/* Move the output file carriage N_CHARS left, to the left margin. */ -static void -return_carriage (struct outp_driver *this, int n_chars) +void +ascii_test_set_length (struct output_driver *driver, int y, int length) { - struct ascii_driver_ext *ext = this->ext; + struct ascii_driver *a = ascii_driver_cast (driver); - switch (ext->carriage_return_style) - { - case CRS_BS: - output_char (this, n_chars, '\b'); - break; - case CRS_CR: - output_char (this, 1, '\r'); - advance_to_left_margin (this); - break; - default: - assert (0); - abort (); - } + if (a->file == NULL && !ascii_open_page (a)) + return; + + if (y < 0 || y >= a->length) + return; + u8_line_set_length (&a->lines[y], length); } + +/* ascii_close_page () and support routines. */ + +#if HAVE_DECL_SIGWINCH +static struct ascii_driver *the_driver; -/* Writes COUNT lines from the line buffer in THIS, starting at line - number FIRST. */ static void -output_lines (struct outp_driver *this, int first, int count) +winch_handler (int signum UNUSED) { - struct ascii_driver_ext *ext = this->ext; - int line_num; - - struct fixed_string *newline = &ext->ops[OPS_NEWLINE]; + update_page_size (the_driver, false); +} +#endif - int n_chars; - int n_passes; +static bool +ascii_open_page (struct ascii_driver *a) +{ + int i; - if (NULL == ext->file.file) - return; + if (a->error) + return false; - /* Iterate over all the lines to be output. */ - for (line_num = first; line_num < first + count; line_num++) + if (a->file == NULL) { - struct line *line = &ext->lines[line_num]; - unsigned short *p = line->chars; - unsigned short *end_p = p + line->char_cnt; - unsigned short *bp, *ep; - unsigned short attr = 0; - - assert (end_p >= p); - - /* Squeeze multiple blank lines into a single blank line if - requested. */ - if (ext->squeeze_blank_lines - && line_num > first - && ext->lines[line_num].char_cnt == 0 - && ext->lines[line_num - 1].char_cnt == 0) - continue; - - /* Output every character in the line in the appropriate - manner. */ - n_passes = 1; - bp = ep = p; - n_chars = 0; - advance_to_left_margin (this); - for (;;) - { - while (ep < end_p && attr == (*ep & 0x0300)) - ep++; - if (output_shorts (this, bp, ep)) - n_passes = 2; - n_chars += ep - bp; - bp = ep; - - if (bp >= end_p) - break; - - /* Turn off old font. */ - if (attr != (OUTP_F_R << 8)) + a->file = fn_open (a->file_name, a->append ? "a" : "w"); + if (a->file != NULL) + { + if ( isatty (fileno (a->file))) { - struct fixed_string *off; - - switch (attr) - { - case OUTP_F_I << 8: - off = &ext->fonts[FSTY_OFF | FSTY_ITALIC]; - break; - case OUTP_F_B << 8: - off = &ext->fonts[FSTY_OFF | FSTY_BOLD]; - break; - case OUTP_F_BI << 8: - off = &ext->fonts[FSTY_OFF | FSTY_BOLD_ITALIC]; - break; - default: - assert (0); - abort (); - } - if (off) - output_string (this, ls_c_str (off), ls_end (off)); +#if HAVE_DECL_SIGWINCH + struct sigaction action; + sigemptyset (&action.sa_mask); + action.sa_flags = 0; + action.sa_handler = winch_handler; + the_driver = a; + sigaction (SIGWINCH, &action, NULL); +#endif + a->auto_width = true; + a->auto_length = true; } + } + else + { + msg_error (errno, _("ascii: opening output file `%s'"), + a->file_name); + a->error = true; + return false; + } + } - /* Turn on new font. */ - attr = (*bp & 0x0300); - if (attr != (OUTP_F_R << 8)) - { - struct fixed_string *on; - - switch (attr) - { - case OUTP_F_I << 8: - on = &ext->fonts[FSTY_ON | FSTY_ITALIC]; - break; - case OUTP_F_B << 8: - on = &ext->fonts[FSTY_ON | FSTY_BOLD]; - break; - case OUTP_F_BI << 8: - on = &ext->fonts[FSTY_ON | FSTY_BOLD_ITALIC]; - break; - default: - assert (0); - abort (); - } - if (on) - output_string (this, ls_c_str (on), ls_end (on)); - } + a->page_number++; - ep = bp + 1; - } - if (n_passes > 1) - { - char ch; + reallocate_lines (a); - return_carriage (this, n_chars); - n_chars = 0; - bp = ep = p; - for (;;) - { - while (ep < end_p && (*ep & 0x0300) == (OUTP_F_R << 8)) - ep++; - if (ep >= end_p) - break; - output_char (this, ep - bp, ' '); - - switch (*ep & 0x0300) - { - case OUTP_F_I << 8: - ch = '_'; - break; - case OUTP_F_B << 8: - ch = *ep; - break; - case OUTP_F_BI << 8: - ch = *ep; - n_passes = 3; - break; - default: - assert (0); - abort (); - } - output_char (this, 1, ch); - n_chars += ep - bp + 1; - bp = ep + 1; - ep = bp; - } - } - if (n_passes > 2) - { - return_carriage (this, n_chars); - bp = ep = p; - for (;;) - { - while (ep < end_p && (*ep & 0x0300) != (OUTP_F_BI << 8)) - ep++; - if (ep >= end_p) - break; - output_char (this, ep - bp, ' '); - output_char (this, 1, '_'); - bp = ep + 1; - ep = bp; - } - } + for (i = 0; i < a->length; i++) + u8_line_clear (&a->lines[i]); - output_string (this, ls_c_str (newline), ls_end (newline)); - } + return true; } - -static int -ascii_close_page (struct outp_driver *this) +static void +output_title_line (FILE *out, int width, const char *left, const char *right) { - static int s_len; - - struct ascii_driver_ext *x = this->ext; - int nl_len, ff_len, total_len; - char *cp; - int i; - - assert (this->driver_open && this->page_open); - - if (!line_buf) - line_buf = xmalloc (LINE_BUF_SIZE); - line_p = line_buf; - - nl_len = ls_length (&x->ops[OPS_NEWLINE]); - if (x->top_margin) + struct string s = DS_EMPTY_INITIALIZER; + ds_put_byte_multiple (&s, ' ', width); + if (left != NULL) { - total_len = x->top_margin * nl_len; - if (s_len < total_len) - { - s_len = total_len; - s = xrealloc (s, s_len); - } - for (cp = s, i = 0; i < x->top_margin; i++) - { - memcpy (cp, ls_c_str (&x->ops[OPS_NEWLINE]), nl_len); - cp += nl_len; - } - output_string (this, s, &s[total_len]); + size_t length = MIN (strlen (left), width); + memcpy (ds_end (&s) - width, left, length); } - if (x->headers) + if (right != NULL) { - int len; - - total_len = nl_len + x->w; - if (s_len < total_len + 1) - { - s_len = total_len + 1; - s = xrealloc (s, s_len); - } - - memset (s, ' ', x->w); - - { - char temp[40]; - - snprintf (temp, 80, _("%s - Page %d"), get_start_date (), - x->page_number); - memcpy (&s[x->w - strlen (temp)], temp, strlen (temp)); - } - - if (outp_title && outp_subtitle) - { - len = min ((int) strlen (outp_title), x->w); - memcpy (s, outp_title, len); - } - memcpy (&s[x->w], ls_c_str (&x->ops[OPS_NEWLINE]), nl_len); - output_string (this, s, &s[total_len]); - - memset (s, ' ', x->w); - len = strlen (version) + 3 + strlen (host_system); - if (len < x->w) - sprintf (&s[x->w - len], "%s - %s" , version, host_system); - if (outp_subtitle || outp_title) - { - char *string = outp_subtitle ? outp_subtitle : outp_title; - len = min ((int) strlen (string), x->w); - memcpy (s, string, len); - } - memcpy (&s[x->w], ls_c_str (&x->ops[OPS_NEWLINE]), nl_len); - output_string (this, s, &s[total_len]); - output_string (this, &s[x->w], &s[total_len]); + size_t length = MIN (strlen (right), width); + memcpy (ds_end (&s) - length, right, length); } - if (line_p != line_buf && !commit_line_buf (this)) - return 0; + ds_put_byte (&s, '\n'); + fputs (ds_cstr (&s), out); + ds_destroy (&s); +} - output_lines (this, 0, x->l); +static void +ascii_close_page (struct ascii_driver *a) +{ + bool any_blank; + int i, y; - ff_len = ls_length (&x->ops[OPS_FORMFEED]); - total_len = x->bottom_margin * nl_len + ff_len; - if (s_len < total_len) - s = xrealloc (s, total_len); - for (cp = s, i = 0; i < x->bottom_margin; i++) - { - memcpy (cp, ls_c_str (&x->ops[OPS_NEWLINE]), nl_len); - cp += nl_len; - } - memcpy (cp, ls_c_str (&x->ops[OPS_FORMFEED]), ff_len); - if ( x->paginate ) - output_string (this, s, &s[total_len]); + a->y = 0; + if (a->file == NULL) + return; - if (line_p != line_buf && !commit_line_buf (this)) - return 0; + if (!a->top_margin && !a->bottom_margin && a->squeeze_blank_lines + && !a->paginate && a->page_number > 1) + putc ('\n', a->file); - this->page_open = 0; - return 1; -} + for (i = 0; i < a->top_margin; i++) + putc ('\n', a->file); + if (a->headers) + { + char *r1, *r2; + r1 = xasprintf (_("%s - Page %d"), get_start_date (), a->page_number); + r2 = xasprintf ("%s - %s" , version, host_system); + output_title_line (a->file, a->width, a->title, r1); + output_title_line (a->file, a->width, a->subtitle, r2); + putc ('\n', a->file); -static void -ascii_chart_initialise(struct outp_driver *d UNUSED, struct chart *ch ) -{ - msg(MW, _("Charts are unsupported with ascii drivers.")); - ch->lp = 0; -} + free (r1); + free (r2); + } -static void -ascii_chart_finalise(struct outp_driver *d UNUSED, struct chart *ch UNUSED) -{ - -} + any_blank = false; + for (y = 0; y < a->allocated_lines; y++) + { + struct u8_line *line = &a->lines[y]; -struct outp_class ascii_class = -{ - "ascii", - 0, - 0, - - ascii_open_global, - ascii_close_global, - ascii_font_sizes, - - ascii_preopen_driver, - ascii_option, - ascii_postopen_driver, - ascii_close_driver, - - ascii_open_page, - ascii_close_page, - - NULL, - - ascii_line_horz, - ascii_line_vert, - ascii_line_intersection, - - ascii_box, - ascii_polyline_begin, - ascii_polyline_point, - ascii_polyline_end, - - ascii_text_set_font_by_name, - ascii_text_set_font_by_position, - ascii_text_set_font_by_family, - ascii_text_get_font_name, - ascii_text_get_font_family, - ascii_text_set_size, - ascii_text_get_size, - ascii_text_metrics, - ascii_text_draw, - - ascii_chart_initialise, - ascii_chart_finalise -}; + if (a->squeeze_blank_lines && y > 0 && line->width == 0) + any_blank = true; + else + { + if (any_blank) + { + putc ('\n', a->file); + any_blank = false; + } + + while (ds_chomp_byte (&line->s, ' ')) + continue; + fwrite (ds_data (&line->s), 1, ds_length (&line->s), a->file); + putc ('\n', a->file); + } + } + if (!a->squeeze_blank_lines) + for (y = a->allocated_lines; y < a->length; y++) + putc ('\n', a->file); + + for (i = 0; i < a->bottom_margin; i++) + putc ('\n', a->file); + if (a->paginate) + putc ('\f', a->file); +}