X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Fascii.c;h=6afefefa0ef15d9b8d328b1055759432b3bd7d8c;hb=173d1687aea88e0e5e1b1d8615ed68ebefb15d08;hp=f6bc7a6f91b3bb6fbe96f920f46639ac5819071f;hpb=a19b858e0ac3c69e4a28c0ca6d8674427268a863;p=pspp diff --git a/src/output/ascii.c b/src/output/ascii.c index f6bc7a6f91..6afefefa0e 100644 --- a/src/output/ascii.c +++ b/src/output/ascii.c @@ -1,108 +1,55 @@ -/* 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 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 -#include -#include -#include "output.h" -#include +#include #include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "error.h" +#include "minmax.h" +#include "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 */ - }; - -/* 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. */ - }; - -/* Basic output strings. */ -enum - { - OPS_INIT, /* Document initialization string. */ - OPS_DONE, /* Document uninit string. */ - OPS_FORMFEED, /* Formfeed string. */ - OPS_NEWLINE, /* Newline string. */ - - OPS_COUNT /* Number of output strings. */ - }; +/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */ +#define H TABLE_HORZ +#define V TABLE_VERT /* Line styles bit shifts. */ enum @@ -115,1578 +62,889 @@ enum LNS_COUNT = 256 }; -/* 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)) +static inline int +make_box_index (int left, int right, int top, int bottom) +{ + return ((left << LNS_LEFT) | (right << LNS_RIGHT) + | (top << LNS_TOP) | (bottom << LNS_BOTTOM)); +} -/* Extract tayste with shift value S from byte B. */ -#define BYTE2TAYSTE(B, S) \ - (((B) >> (S)) & 3) +/* Character attributes. */ +#define ATTR_EMPHASIS 0x100 /* Bold-face. */ +#define ATTR_BOX 0x200 /* Line drawing character. */ -/* Font style; take one of the first group |'d with one of the second group. */ -enum +/* A line of text. */ +struct ascii_line { - 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. */ + unsigned short *chars; /* Characters and attributes. */ + int n_chars; /* Length. */ + int allocated_chars; /* Allocated "chars" elements. */ }; -/* A line of text. */ -struct line +/* How to emphasize text. */ +enum emphasis_style { - unsigned short *chars; /* Characters and attributes. */ - int char_cnt; /* Length. */ - int char_cap; /* Allocated bytes. */ + EMPH_BOLD, /* Overstrike for bold. */ + EMPH_UNDERLINE, /* Overstrike for underlining. */ + EMPH_NONE /* No emphasis. */ }; -/* ASCII output driver extension record. */ -struct ascii_driver_ext +/* ASCII output driver. */ +struct ascii_driver { + struct output_driver driver; + /* 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. */ + + 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. */ + + char *box[LNS_COUNT]; /* Line & box drawing characters. */ + char *init; /* Device initialization string. */ /* 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 ascii_line *lines; /* Page content. */ + int allocated_lines; /* Number of lines allocated. */ + int chart_cnt; /* Number of charts so far. */ + int y; }; -static int postopen (struct file_ext *); -static int preclose (struct file_ext *); +static const struct output_driver_class ascii_driver_class; + +static void ascii_submit (struct output_driver *, const struct output_item *); + +static int vertical_margins (const struct ascii_driver *); -static struct outp_option_info *option_info; +static const char *get_default_box (int right, int bottom, int left, int top); +static bool update_page_size (struct ascii_driver *, bool issue_error); +static int parse_page_size (struct driver_option *); -static int -ascii_open_global (struct outp_class *this UNUSED) -{ - option_info = xmalloc (sizeof *option_info); - option_info->initial = 0; - option_info->options = 0; - return 1; -} +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 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; -#endif - return 1; -} + struct output_driver *d; + struct ascii_driver *a; + int paper_length; + int right, bottom, left, top; -static int -ascii_postopen_driver (struct outp_driver *this) -{ - 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")) - { - ls_create (&x->ops[OPS_NEWLINE], "\n"); - x->file.mode = "wt"; - } - - { - 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; -} + 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, + (char *) NULL); -static int -ascii_close_driver (struct outp_driver *this) -{ - 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; -} + a->chart_file_name = parse_chart_file_name (opt (d, o, "charts", file_name)); -/* Generic option types. */ -enum - { - pos_int_arg = -10, - nonneg_int_arg, - string_arg, - font_string_arg, - boolean_arg - }; + 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); -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}, - }; + 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); -static void -ascii_option (struct outp_driver *this, const char *key, - const struct string *val) -{ - struct ascii_driver_ext *x = this->ext; - int cat, subcat; - const char *value; + for (right = 0; right < 4; right++) + for (bottom = 0; bottom < 4; bottom++) + for (left = 0; left < 4; left++) + for (top = 0; top < 4; top++) + { + int indx = make_box_index (left, right, top, bottom); + const char *default_value; + char name[16]; - 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; - } + sprintf (name, "box[%d%d%d%d]", right, bottom, left, top); + default_value = get_default_box (right, bottom, left, top); + a->box[indx] = parse_string (opt (d, o, name, default_value)); + } + a->init = parse_string (opt (d, o, "init", "")); - cat = outp_match_keyword (key, option_tab, option_info, &subcat); - switch (cat) - { - 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); - } -} + 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; -int -postopen (struct file_ext *f) -{ - struct ascii_driver_ext *x = f->param; - struct fixed_string *s = &x->ops[OPS_INIT]; + if (!update_page_size (a, true)) + goto error; - 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; + return d; + +error: + output_driver_destroy (d); + return NULL; } -int -preclose (struct file_ext *f) +static const char * +get_default_box (int right, int bottom, int left, int top) { - 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) + switch ((top << 12) | (left << 8) | (bottom << 4) | (right << 0)) { - msg (ME, _("ASCII output driver: %s: %s"), - f->filename, strerror (errno)); - return 0; + case 0x0000: + return " "; + + case 0x0100: case 0x0101: case 0x0001: + return "-"; + + case 0x1000: case 0x1010: case 0x0010: + return "|"; + + case 0x0300: case 0x0303: case 0x0003: + case 0x0200: case 0x0202: case 0x0002: + return "="; + + default: + return left > 1 || top > 1 || right > 1 || bottom > 1 ? "#" : "+"; } - return 1; } static int -ascii_open_page (struct outp_driver *this) +parse_page_size (struct driver_option *option) { - struct ascii_driver_ext *x = this->ext; - int i; - - assert (this->driver_open && !this->page_open); - x->page_number++; - if (!fn_open_ext (&x->file)) - { - msg (ME, _("ASCII output driver: %s: %s"), x->file.filename, - strerror (errno)); - return 0; - } + int dim = atol (option->default_value); - if (x->l > x->lines_cap) + if (option->value != NULL) { - x->lines = xnrealloc (x->lines, x->l, sizeof *x->lines); - for (i = x->lines_cap; i < x->l; i++) + if (!strcmp (option->value, "auto")) + dim = -1; + else { - struct line *line = &x->lines[i]; - line->chars = NULL; - line->char_cap = 0; + int value; + char *tail; + + errno = 0; + value = strtol (option->value, &tail, 0); + if (dim >= 1 && errno != ERANGE && *tail == '\0') + dim = value; + else + error (0, 0, _("%s: %s must be positive integer or `auto'"), + option->driver_name, option->name); } - x->lines_cap = x->l; } - for (i = 0; i < x->l; i++) - x->lines[i].char_cnt = 0; + driver_option_destroy (option); - this->page_open = 1; - return 1; + return dim; } -/* 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 int +vertical_margins (const struct ascii_driver *a) { - struct line *line; - int j; - - 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; + return a->top_margin + a->bottom_margin + (a->headers ? 3 : 0); } -/* 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; + enum { MIN_WIDTH = 6, MIN_LENGTH = 6 }; - assert (this->driver_open && this->page_open); - if (x1 == x2) - return; -#if DEBUGGING - if (x1 > x2 - || x1 < 0 || x1 >= ext->w - || x2 <= 0 || x2 > ext->w - || y1 < 0 || y1 >= ext->l) + if (a->auto_width) + a->width = settings_get_viewwidth (); + if (a->auto_length) + a->length = settings_get_viewlength () - vertical_margins (a); + + if (a->width < MIN_WIDTH || a->length < MIN_LENGTH) { -#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; + if (issue_error) + error (0, 0, + _("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; } -#endif - if (ext->lines[y1].char_cnt < x2) - expand_line (ext, y1, x2); - - for (x = x1; x < x2; x++) - draw_line (x, y1, (style << LNS_LEFT) | (style << LNS_RIGHT)); + return true; } static void -ascii_line_vert (struct outp_driver *this, const struct rect *r, - const struct color *c UNUSED, int style) +ascii_destroy (struct output_driver *driver) { - 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; - - 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) - { -#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; - } -#endif + struct ascii_driver *a = ascii_driver_cast (driver); + int i; - for (y = y1; y < y2; y++) - if (ext->lines[y].char_cnt <= x1) - expand_line (ext, y, x1 + 1); + if (a->y > 0) + ascii_close_page (a); - for (y = y1; y < y2; y++) - draw_line (x1, y, (style << LNS_TOP) | (style << LNS_BOTTOM)); + 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 < LNS_COUNT; i++) + free (a->box[i]); + free (a->init); + for (i = 0; i < a->allocated_lines; i++) + free (a->lines[i].chars); + free (a->lines); + free (a); } static void -ascii_line_intersection (struct outp_driver *this, const struct rect *r, - const struct color *c UNUSED, - const struct outp_styles *style) +ascii_flush (struct output_driver *driver) { - 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 = ascii_driver_cast (driver); + if (a->y > 0) { -#if !SUPPRESS_WARNINGS - printf (_("ascii_line_intersection: bad intsct (%d,%d) out of (%d,%d)\n"), - x, y, ext->w, ext->l); -#endif - return; - } -#endif - - l = ((style->l << LNS_LEFT) | (style->r << LNS_RIGHT) - | (style->t << LNS_TOP) | (style->b << LNS_BOTTOM)); + ascii_close_page (a); - if (ext->lines[y].char_cnt <= x) - expand_line (ext, y, x + 1); - draw_line (x, y, l); + if (fn_close (a->file_name, a->file) != 0) + error (0, errno, _("ascii: closing output file `%s'"), + a->file_name); + a->file = NULL; + } } -/* 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_init_caption_cell (const char *caption, struct table_cell *cell) { - assert (this->driver_open && this->page_open); + cell->contents = caption; + cell->options = TAB_LEFT; + cell->destructor = NULL; } -/* 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) -{ - assert (this->driver_open && this->page_open); -} +ascii_output_table_item (struct ascii_driver *a, + const struct table_item *table_item) +{ + const char *caption = table_item_get_caption (table_item); + struct render_params params; + struct render_page *page; + struct render_break x_break; + int caption_height; + int i; -static void -ascii_text_set_font_by_name (struct outp_driver * this, const char *s) -{ - struct ascii_driver_ext *x = this->ext; - int len = strlen (s); + update_page_size (a, false); + + if (caption != NULL) + { + /* XXX doesn't do well with very large captions */ + struct table_cell cell; + ascii_init_caption_cell (caption, &cell); + caption_height = ascii_measure_cell_height (a, &cell, a->width); + } + else + caption_height = 0; - assert (this->driver_open && this->page_open); - x->cur_font = OUTP_F_R; - if (len == 0) + params.draw_line = ascii_draw_line; + params.measure_cell_width = ascii_measure_cell_width; + params.measure_cell_height = ascii_measure_cell_height; + params.draw_cell = ascii_draw_cell, + params.aux = a; + params.size[H] = a->width; + params.size[V] = a->length - caption_height; + params.font_size[H] = 1; + params.font_size[V] = 1; + for (i = 0; i < RENDER_N_LINES; i++) + { + int width = i == RENDER_LINE_NONE ? 0 : 1; + params.line_widths[H][i] = width; + params.line_widths[V][i] = width; + } + + if (a->file == NULL && !ascii_open_page (a)) return; - if (s[len - 1] == 'I') + + page = render_page_create (¶ms, table_item_get_table (table_item)); + for (render_break_init (&x_break, page, H); + render_break_has_next (&x_break); ) { - if (len > 1 && s[len - 2] == 'B') - x->cur_font = OUTP_F_BI; - else - x->cur_font = OUTP_F_I; + struct render_page *x_slice; + struct render_break y_break; + + x_slice = render_break_next (&x_break, a->width); + for (render_break_init (&y_break, x_slice, V); + render_break_has_next (&y_break); ) + { + struct render_page *y_slice; + int space; + + if (a->y > 0) + a->y++; + + space = a->length - a->y - caption_height; + if (render_break_next_size (&y_break) > space) + { + assert (a->y > 0); + ascii_close_page (a); + if (!ascii_open_page (a)) + return; + continue; + } + + y_slice = render_break_next (&y_break, space); + if (caption_height) + { + struct table_cell cell; + int bb[TABLE_N_AXES][2]; + + ascii_init_caption_cell (caption, &cell); + bb[H][0] = 0; + bb[H][1] = a->width; + bb[V][0] = 0; + bb[V][1] = caption_height; + ascii_draw_cell (a, &cell, bb, bb); + a->y += caption_height; + caption_height = 0; + } + render_page_draw (y_slice); + a->y += render_page_get_size (y_slice, V); + render_page_unref (y_slice); + } + render_break_destroy (&y_break); } - else if (s[len - 1] == 'B') - x->cur_font = OUTP_F_B; + render_break_destroy (&x_break); } static void -ascii_text_set_font_by_position (struct outp_driver *this, int pos) +ascii_output_text (struct ascii_driver *a, const char *text) { - struct ascii_driver_ext *x = this->ext; - assert (this->driver_open && this->page_open); - x->cur_font = pos >= 0 && pos < 4 ? pos : 0; + struct table_item *table_item; + + table_item = table_item_create (table_from_string (TAB_LEFT, text), NULL); + ascii_output_table_item (a, table_item); + table_item_unref (table_item); } static void -ascii_text_set_font_by_family (struct outp_driver *this UNUSED, const char *s UNUSED) +ascii_submit (struct output_driver *driver, + const struct output_item *output_item) { - assert (this->driver_open && this->page_open); -} + struct ascii_driver *a = ascii_driver_cast (driver); -static const char * -ascii_text_get_font_name (struct outp_driver *this) -{ - struct ascii_driver_ext *x = this->ext; + output_driver_track_current_command (output_item, &a->command_name); + + if (a->error) + return; - assert (this->driver_open && this->page_open); - switch (x->cur_font) + 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) { - case OUTP_F_R: - return "R"; - case OUTP_F_I: - return "I"; - case OUTP_F_B: - return "B"; - case OUTP_F_BI: - return "BI"; - default: - assert (0); - } - abort (); -} + struct chart_item *chart_item = to_chart_item (output_item); + char *file_name; -static const char * -ascii_text_get_font_family (struct outp_driver *this UNUSED) -{ - assert (this->driver_open && this->page_open); - return ""; -} + file_name = xr_draw_png_chart (chart_item, a->chart_file_name, + a->chart_cnt++); + if (file_name != NULL) + { + struct text_item *text_item; -static int -ascii_text_set_size (struct outp_driver *this, int size) -{ - assert (this->driver_open && this->page_open); - return size == this->vert; -} + text_item = text_item_create_format ( + TEXT_ITEM_PARAGRAPH, _("See %s for a chart."), file_name); -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; + 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); + + 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_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)) + { + 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); + } } -static void text_draw (struct outp_driver *this, struct outp_text *t); +const struct output_driver_factory txt_driver_factory = + { "txt", ascii_create }; +const struct output_driver_factory list_driver_factory = + { "list", ascii_create }; + +static const struct output_driver_class ascii_driver_class = + { + "text", + ascii_destroy, + ascii_submit, + ascii_flush, + }; + +enum wrap_mode + { + WRAP_WORD, + WRAP_CHAR, + WRAP_WORD_CHAR + }; -/* 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. +static void ascii_expand_line (struct ascii_driver *, int y, int length); +static void ascii_layout_cell (struct ascii_driver *, + const struct table_cell *, + int bb[TABLE_N_AXES][2], + int clip[TABLE_N_AXES][2], enum wrap_mode wrap, + int *width, int *height); - You probably don't want to look at this code. */ static void -delineate (struct outp_driver *this, struct outp_text *t, int draw) +ascii_draw_line (void *a_, int bb[TABLE_N_AXES][2], + enum render_line_style styles[TABLE_N_AXES][2]) { - /* Width we're fitting everything into. */ - int width = t->h / this->horiz; + struct ascii_driver *a = a_; + unsigned short int value; + int x1, y1; + int x, y; - /* Maximum `y' position we can write to. */ - int max_y; - - /* Current position in string, character following end of string. */ - const char *s = ls_c_str (&t->s); - const char *end = ls_end (&t->s); - - /* Temporary struct outp_text to pass to low-level function. */ - struct outp_text temp; + /* Clip to the page. */ + if (bb[H][0] >= a->width || bb[V][0] + a->y >= a->length) + return; + x1 = MIN (bb[H][1], a->width); + y1 = MIN (bb[V][1] + a->y, a->length); -#if DEBUGGING && 0 - if (!ext->debug) + /* Draw. */ + value = ATTR_BOX | make_box_index (styles[V][0], styles[V][1], + styles[H][0], styles[H][1]); + for (y = bb[V][0] + a->y; y < y1; y++) { - ext->debug = 1; - printf (_("%s: horiz=%d, vert=%d\n"), this->name, this->horiz, this->vert); + ascii_expand_line (a, y, x1); + for (x = bb[H][0]; x < x1; x++) + a->lines[y].chars[x] = value; } -#endif +} - if (!width) - { - t->h = t->v = 0; - return; - } +static void +ascii_measure_cell_width (void *a_, const struct table_cell *cell, + int *min_width, int *max_width) +{ + 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, WRAP_WORD, max_width, &h); - if (draw) + if (strchr (cell->contents, ' ')) { - temp.options = t->options; - ls_shallow_copy (&temp.s, &t->s); - temp.h = t->h / this->horiz; - temp.x = t->x / this->horiz; + bb[H][1] = 1; + ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, min_width, &h); } 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; - 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; - } + *min_width = *max_width; +} - /* 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++; - } +static int +ascii_measure_cell_height (void *a_, const struct table_cell *cell, int width) +{ + struct ascii_driver *a = a_; + int bb[TABLE_N_AXES][2]; + int clip[TABLE_N_AXES][2]; + int w, h; - t->v = (temp.y * this->vert) - t->y; + 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, WRAP_WORD, &w, &h); + return h; } static void -ascii_text_metrics (struct outp_driver *this, struct outp_text *t) +ascii_draw_cell (void *a_, const struct table_cell *cell, + int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2]) { - 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; - } - else - delineate (this, t, 0); + struct ascii_driver *a = a_; + int w, h; + + ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, &w, &h); } +/* Ensures that at least the first LENGTH characters of line Y in + ascii driver A have been cleared out. */ static void -ascii_text_draw (struct outp_driver *this, struct outp_text *t) +ascii_expand_line (struct ascii_driver *a, int y, int length) { - /* FIXME: orientations not supported. */ - assert (this->driver_open && this->page_open); - if (!(t->options & OUTP_T_HORZ)) + struct ascii_line *line = &a->lines[y]; + if (line->n_chars < length) { - 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; + int x; + if (line->allocated_chars < length) + { + line->allocated_chars = MAX (length, MIN (length * 2, a->width)); + line->chars = xnrealloc (line->chars, line->allocated_chars, + sizeof *line->chars); + } + for (x = line->n_chars; x < length; x++) + line->chars[x] = ' '; + line->n_chars = length; } - delineate (this, t, 1); } 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; - - int x = t->x; - int y = t->y; - - char *s = ls_c_str (&t->s); +text_draw (struct ascii_driver *a, const struct table_cell *cell, + int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2], + int y, const char *string, int n) +{ + int x0 = MAX (0, clip[H][0]); + int y0 = MAX (0, clip[V][0] + a->y); + int x1 = clip[H][1]; + int y1 = MIN (a->length, clip[V][1] + a->y); + int x; - /* Expand the line with the assumption that S takes up LEN character - spaces (sometimes it takes up less). */ - int min_len; + y += a->y; + if (y < y0 || y >= y1) + return; - assert (this->driver_open && this->page_open); - switch (t->options & OUTP_T_JUST_MASK) + switch (cell->options & TAB_ALIGNMENT) { - case OUTP_T_JUST_LEFT: + case TAB_LEFT: + x = bb[H][0]; + break; + case TAB_CENTER: + x = (bb[H][0] + bb[H][1] - n + 1) / 2; break; - case OUTP_T_JUST_CENTER: - x -= (t->h - t->w) / 2; /* fall through */ - case OUTP_T_JUST_RIGHT: - x += (t->h - t->w); + case TAB_RIGHT: + x = bb[H][1] - n; break; default: - assert (0); + NOT_REACHED (); } - 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); + if (x0 > x) + { + n -= x0 - x; + if (n <= 0) + return; + string += x0 - x; + x = x0; + } + if (x + n >= x1) + n = x1 - x; - { - int len = ls_length (&t->s); + if (n > 0) + { + int attr = cell->options & TAB_EMPH ? ATTR_EMPHASIS : 0; + size_t i; - if (len + x > ext->w) - len = ext->w - x; - while (len--) - ext->lines[y].chars[x++] = *s++ | attr; - } + ascii_expand_line (a, y, x + n); + for (i = 0; i < n; i++) + a->lines[y].chars[x + i] = string[i] | attr; + } } - -/* ascii_close_page () and support routines. */ - -#define LINE_BUF_SIZE 1024 -static char *line_buf; -static char *line_p; -static inline int -commit_line_buf (struct outp_driver *this) +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], + enum wrap_mode wrap, int *width, int *height) { - struct ascii_driver_ext *x = this->ext; - - if ((int) fwrite (line_buf, 1, line_p - line_buf, x->file.file) - < line_p - line_buf) + size_t length = strlen (cell->contents); + int y, pos; + + *width = 0; + pos = 0; + for (y = bb[V][0]; y < bb[V][1] && pos < length; y++) { - msg (ME, _("Writing `%s': %s"), x->file.filename, strerror (errno)); - return 0; - } + const char *line = &cell->contents[pos]; + const char *new_line; + size_t line_len; - line_p = line_buf; - return 1; -} + /* Find line length without considering word wrap. */ + line_len = MIN (bb[H][1] - bb[H][0], length - pos); + new_line = memchr (line, '\n', line_len); + if (new_line != NULL) + line_len = new_line - line; -/* 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) -{ - if (LINE_BUF_SIZE - (line_p - line_buf) >= ep - bp) - { - memcpy (line_p, bp, ep - bp); - line_p += ep - bp; + /* Word wrap. */ + if (pos + line_len < length && wrap != WRAP_CHAR) + { + size_t space_len = line_len; + while (space_len > 0 && !isspace ((unsigned char) line[space_len])) + space_len--; + if (space_len > 0) + line_len = space_len; + else if (wrap == WRAP_WORD) + { + while (pos + line_len < length + && !isspace ((unsigned char) line[line_len])) + line_len++; + } + } + if (line_len > *width) + *width = line_len; + + /* Draw text. */ + text_draw (a, cell, bb, clip, y, line, line_len); + + /* Next line. */ + pos += line_len; + if (pos < length && isspace ((unsigned char) cell->contents[pos])) + pos++; } - else - while (bp < ep) - { - if (LINE_BUF_SIZE - (line_p - line_buf) <= 1 && !commit_line_buf (this)) - return; - *line_p++ = *bp++; - } + *height = y - bb[V][0]; } + +/* ascii_close_page () and support routines. */ -/* 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) +static bool +ascii_open_page (struct ascii_driver *a) { - struct ascii_driver_ext *ext = this->ext; - size_t remaining = LINE_BUF_SIZE - (line_p - line_buf); - int result = 0; + int i; + + if (a->error) + return false; - for (; bp < ep; bp++) + if (a->file == NULL) { - if (*bp & 0x800) - { - struct fixed_string *box = &ext->box[*bp & 0xff]; - size_t len = ls_length (box); - - 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--; - } + a->file = fn_open (a->file_name, a->append ? "a" : "w"); + if (a->file != NULL) + { + if (a->init != NULL) + fputs (a->init, a->file); + } else - { - if (!commit_line_buf (this)) - return 0; - remaining = LINE_BUF_SIZE - (line_p - line_buf); - *line_p++ = *bp; - } + { + error (0, errno, _("ascii: opening output file `%s'"), + a->file_name); + a->error = true; + return false; + } } - return result; -} + a->page_number++; -/* 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) -{ - if (LINE_BUF_SIZE - (line_p - line_buf) >= n) + if (a->length > a->allocated_lines) { - memset (line_p, ch, n); - line_p += n; + a->lines = xnrealloc (a->lines, a->length, sizeof *a->lines); + for (i = a->allocated_lines; i < a->length; i++) + { + struct ascii_line *line = &a->lines[i]; + line->chars = NULL; + line->allocated_chars = 0; + } + a->allocated_lines = a->length; } - else - while (n--) - { - if (LINE_BUF_SIZE - (line_p - line_buf) <= 1 && !commit_line_buf (this)) - return; - *line_p++ = ch; - } + + for (i = 0; i < a->length; i++) + a->lines[i].n_chars = 0; + + return true; } -/* Advance the carriage from column 0 to the left margin. */ +/* Writes LINE to A's output file. */ static void -advance_to_left_margin (struct outp_driver *this) +output_line (struct ascii_driver *a, const struct ascii_line *line) { - struct ascii_driver_ext *ext = this->ext; - int margin; + size_t length; + size_t i; - margin = ext->left_margin; - if (margin == 0) - return; - if (ext->tab_width && margin >= ext->tab_width) + length = line->n_chars; + while (length > 0 && line->chars[length - 1] == ' ') + length--; + + for (i = 0; i < length; i++) { - output_char (this, margin / ext->tab_width, '\t'); - margin %= ext->tab_width; + int attribute = line->chars[i] & (ATTR_BOX | ATTR_EMPHASIS); + int ch = line->chars[i] & ~(ATTR_BOX | ATTR_EMPHASIS); + + switch (attribute) + { + case ATTR_BOX: + fputs (a->box[ch], a->file); + break; + + case ATTR_EMPHASIS: + if (a->emphasis == EMPH_BOLD) + fprintf (a->file, "%c\b%c", ch, ch); + else if (a->emphasis == EMPH_UNDERLINE) + fprintf (a->file, "_\b%c", ch); + else + putc (ch, a->file); + break; + + default: + putc (ch, a->file); + break; + } } - if (margin) - output_char (this, margin, ' '); + + putc ('\n', a->file); } -/* Move the output file carriage N_CHARS left, to the left margin. */ static void -return_carriage (struct outp_driver *this, int n_chars) +output_title_line (FILE *out, int width, const char *left, const char *right) { - struct ascii_driver_ext *ext = this->ext; - - switch (ext->carriage_return_style) + struct string s = DS_EMPTY_INITIALIZER; + ds_put_char_multiple (&s, ' ', width); + if (left != NULL) { - 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 (); + size_t length = MIN (strlen (left), width); + memcpy (ds_end (&s) - width, left, length); } + if (right != NULL) + { + size_t length = MIN (strlen (right), width); + memcpy (ds_end (&s) - length, right, length); + } + ds_put_char (&s, '\n'); + fputs (ds_cstr (&s), out); + ds_destroy (&s); } -/* 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) +ascii_close_page (struct ascii_driver *a) { - struct ascii_driver_ext *ext = this->ext; - int line_num; - - struct fixed_string *newline = &ext->ops[OPS_NEWLINE]; + bool any_blank; + int i, y; - int n_chars; - int n_passes; - - if (NULL == ext->file.file) + a->y = 0; + if (a->file == NULL) return; - /* Iterate over all the lines to be output. */ - for (line_num = first; line_num < first + count; line_num++) - { - 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)) - { - 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)); - } - - /* 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)); - } - - ep = bp + 1; - } - if (n_passes > 1) - { - char ch; - - 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; - } - } - - output_string (this, ls_c_str (newline), ls_end (newline)); - } -} - + if (!a->top_margin && !a->bottom_margin && a->squeeze_blank_lines + && !a->paginate && a->page_number > 1) + putc ('\n', a->file); -static int -ascii_close_page (struct outp_driver *this) -{ - static int s_len; + for (i = 0; i < a->top_margin; i++) + putc ('\n', a->file); + if (a->headers) + { + char *r1, *r2; - struct ascii_driver_ext *x = this->ext; - int nl_len, ff_len, total_len; - char *cp; - int i; + r1 = xasprintf (_("%s - Page %d"), get_start_date (), a->page_number); + r2 = xasprintf ("%s - %s" , version, host_system); - assert (this->driver_open && this->page_open); - - if (!line_buf) - line_buf = xmalloc (LINE_BUF_SIZE); - line_p = line_buf; + output_title_line (a->file, a->width, a->title, r1); + output_title_line (a->file, a->width, a->subtitle, r2); + putc ('\n', a->file); - nl_len = ls_length (&x->ops[OPS_NEWLINE]); - if (x->top_margin) - { - 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]); + free (r1); + free (r2); } - if (x->headers) - { - 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]); - } - if (line_p != line_buf && !commit_line_buf (this)) - return 0; - - output_lines (this, 0, x->l); - 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++) + any_blank = false; + for (y = 0; y < a->allocated_lines; y++) { - 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]); - - if (line_p != line_buf && !commit_line_buf (this)) - return 0; - - this->page_open = 0; - return 1; -} - + struct ascii_line *line = &a->lines[y]; + if (a->squeeze_blank_lines && y > 0 && line->n_chars == 0) + any_blank = true; + else + { + if (any_blank) + { + putc ('\n', a->file); + any_blank = false; + } -static void -ascii_chart_initialise(struct outp_driver *d UNUSED, struct chart *ch ) -{ - msg(MW, _("Charts are unsupported with ascii drivers.")); - ch->lp = 0; -} + output_line (a, line); + } + } + if (!a->squeeze_blank_lines) + for (y = a->allocated_lines; y < a->length; y++) + putc ('\n', a->file); -static void -ascii_chart_finalise(struct outp_driver *d UNUSED, struct chart *ch UNUSED) -{ - + for (i = 0; i < a->bottom_margin; i++) + putc ('\n', a->file); + if (a->paginate) + putc ('\f', a->file); } - -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 -};