1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2007, 2009 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include <data/file-name.h>
26 #include <data/settings.h>
27 #include <libpspp/assertion.h>
28 #include <libpspp/compiler.h>
29 #include <libpspp/start-date.h>
30 #include <libpspp/string-map.h>
31 #include <libpspp/version.h>
32 #include <output/cairo.h>
33 #include <output/chart-item-provider.h>
34 #include "output/options.h"
35 #include <output/tab.h>
36 #include <output/text-item.h>
37 #include <output/driver-provider.h>
38 #include <output/render.h>
39 #include <output/table-item.h>
46 #define _(msgid) gettext (msgid)
48 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
52 /* Line styles bit shifts. */
64 make_box_index (int left, int right, int top, int bottom)
66 return ((left << LNS_LEFT) | (right << LNS_RIGHT)
67 | (top << LNS_TOP) | (bottom << LNS_BOTTOM));
70 /* Character attributes. */
71 #define ATTR_EMPHASIS 0x100 /* Bold-face. */
72 #define ATTR_BOX 0x200 /* Line drawing character. */
77 unsigned short *chars; /* Characters and attributes. */
78 int n_chars; /* Length. */
79 int allocated_chars; /* Allocated "chars" elements. */
82 /* How to emphasize text. */
85 EMPH_BOLD, /* Overstrike for bold. */
86 EMPH_UNDERLINE, /* Overstrike for underlining. */
87 EMPH_NONE /* No emphasis. */
90 /* ASCII output driver. */
93 struct output_driver driver;
95 /* User parameters. */
96 bool append; /* Append if output-file already exists? */
97 bool headers; /* Print headers at top of page? */
98 bool paginate; /* Insert formfeeds? */
99 bool squeeze_blank_lines; /* Squeeze multiple blank lines into one? */
100 enum emphasis_style emphasis; /* How to emphasize text. */
101 char *chart_file_name; /* Name of files used for charts. */
103 int width; /* Page width. */
104 int length; /* Page length minus margins and header. */
105 bool auto_width; /* Use viewwidth as page width? */
106 bool auto_length; /* Use viewlength as page width? */
108 int top_margin; /* Top margin in lines. */
109 int bottom_margin; /* Bottom margin in lines. */
111 char *box[LNS_COUNT]; /* Line & box drawing characters. */
112 char *init; /* Device initialization string. */
114 /* Internal state. */
117 char *file_name; /* Output file name. */
118 FILE *file; /* Output file. */
119 bool error; /* Output error? */
120 int page_number; /* Current page number. */
121 struct ascii_line *lines; /* Page content. */
122 int allocated_lines; /* Number of lines allocated. */
123 int chart_cnt; /* Number of charts so far. */
127 static int vertical_margins (const struct ascii_driver *);
129 static const char *get_default_box (int right, int bottom, int left, int top);
130 static bool update_page_size (struct ascii_driver *, bool issue_error);
131 static int parse_page_size (struct driver_option *);
133 static void ascii_close_page (struct ascii_driver *);
134 static bool ascii_open_page (struct ascii_driver *);
136 static void ascii_draw_line (void *, int bb[TABLE_N_AXES][2],
137 enum render_line_style styles[TABLE_N_AXES][2]);
138 static void ascii_measure_cell_width (void *, const struct table_cell *,
140 static int ascii_measure_cell_height (void *, const struct table_cell *,
142 static void ascii_draw_cell (void *, const struct table_cell *,
143 int bb[TABLE_N_AXES][2],
144 int clip[TABLE_N_AXES][2]);
146 static struct ascii_driver *
147 ascii_driver_cast (struct output_driver *driver)
149 assert (driver->class == &ascii_class);
150 return UP_CAST (driver, struct ascii_driver, driver);
153 static struct driver_option *
154 opt (struct output_driver *d, struct string_map *options, const char *key,
155 const char *default_value)
157 return driver_option_get (d, options, key, default_value);
160 static struct output_driver *
161 ascii_create (const char *name, enum output_device_type device_type,
162 struct string_map *o)
164 struct output_driver *d;
165 struct ascii_driver *a;
167 int right, bottom, left, top;
169 a = xzalloc (sizeof *a);
171 output_driver_init (&a->driver, &ascii_class, name, device_type);
172 a->append = parse_boolean (opt (d, o, "append", "false"));
173 a->headers = parse_boolean (opt (d, o, "headers", "true"));
174 a->paginate = parse_boolean (opt (d, o, "paginate", "true"));
175 a->squeeze_blank_lines = parse_boolean (opt (d, o, "squeeze", "false"));
176 a->emphasis = parse_enum (opt (d, o, "emphasis", "bold"),
178 "underline", EMPH_UNDERLINE,
182 if (parse_enum (opt (d, o, "chart-type", "png"),
186 a->chart_file_name = parse_chart_file_name (opt (d, o, "chart-files",
189 a->chart_file_name = NULL;
191 a->top_margin = parse_int (opt (d, o, "top-margin", "2"), 0, INT_MAX);
192 a->bottom_margin = parse_int (opt (d, o, "bottom-margin", "2"), 0, INT_MAX);
194 a->width = parse_page_size (opt (d, o, "width", "79"));
195 paper_length = parse_page_size (opt (d, o, "length", "66"));
196 a->auto_width = a->width < 0;
197 a->auto_length = paper_length < 0;
198 a->length = paper_length - vertical_margins (a);
200 for (right = 0; right < 4; right++)
201 for (bottom = 0; bottom < 4; bottom++)
202 for (left = 0; left < 4; left++)
203 for (top = 0; top < 4; top++)
205 int indx = make_box_index (left, right, top, bottom);
206 const char *default_value;
209 sprintf (name, "box[%d%d%d%d]", right, bottom, left, top);
210 default_value = get_default_box (right, bottom, left, top);
211 a->box[indx] = parse_string (opt (d, o, name, default_value));
213 a->init = parse_string (opt (d, o, "init", ""));
215 a->title = xstrdup ("");
216 a->subtitle = xstrdup ("");
217 a->file_name = parse_string (opt (d, o, "output-file", "pspp.list"));
222 a->allocated_lines = 0;
225 if (!update_page_size (a, true))
231 output_driver_destroy (d);
236 get_default_box (int right, int bottom, int left, int top)
238 switch ((top << 12) | (left << 8) | (bottom << 4) | (right << 0))
243 case 0x0100: case 0x0101: case 0x0001:
246 case 0x1000: case 0x1010: case 0x0010:
249 case 0x0300: case 0x0303: case 0x0003:
250 case 0x0200: case 0x0202: case 0x0002:
254 return left > 1 || top > 1 || right > 1 || bottom > 1 ? "#" : "+";
259 parse_page_size (struct driver_option *option)
261 int dim = atol (option->default_value);
263 if (option->value != NULL)
265 if (!strcmp (option->value, "auto"))
273 value = strtol (option->value, &tail, 0);
274 if (dim >= 1 && errno != ERANGE && *tail == '\0')
277 error (0, 0, _("%s: %s must be positive integer or `auto'"),
278 option->driver_name, option->name);
282 driver_option_destroy (option);
288 vertical_margins (const struct ascii_driver *a)
290 return a->top_margin + a->bottom_margin + (a->headers ? 3 : 0);
293 /* Re-calculates the page width and length based on settings,
294 margins, and, if "auto" is set, the size of the user's
295 terminal window or GUI output window. */
297 update_page_size (struct ascii_driver *a, bool issue_error)
299 enum { MIN_WIDTH = 6, MIN_LENGTH = 6 };
302 a->width = settings_get_viewwidth ();
304 a->length = settings_get_viewlength () - vertical_margins (a);
306 if (a->width < MIN_WIDTH || a->length < MIN_LENGTH)
310 _("ascii: page excluding margins and headers "
311 "must be at least %d characters wide by %d lines long, but "
312 "as configured is only %d characters by %d lines"),
313 MIN_WIDTH, MIN_LENGTH,
314 a->width, a->length);
315 if (a->width < MIN_WIDTH)
316 a->width = MIN_WIDTH;
317 if (a->length < MIN_LENGTH)
318 a->length = MIN_LENGTH;
326 ascii_destroy (struct output_driver *driver)
328 struct ascii_driver *a = ascii_driver_cast (driver);
332 ascii_close_page (a);
335 fn_close (a->file_name, a->file);
339 free (a->chart_file_name);
340 for (i = 0; i < LNS_COUNT; i++)
343 for (i = 0; i < a->allocated_lines; i++)
344 free (a->lines[i].chars);
350 ascii_flush (struct output_driver *driver)
352 struct ascii_driver *a = ascii_driver_cast (driver);
355 ascii_close_page (a);
357 if (fn_close (a->file_name, a->file) != 0)
358 error (0, errno, _("ascii: closing output file \"%s\""),
365 ascii_init_caption_cell (const char *caption, struct table_cell *cell)
367 cell->contents = caption;
368 cell->options = TAB_LEFT;
369 cell->destructor = NULL;
373 ascii_submit (struct output_driver *driver,
374 const struct output_item *output_item)
376 struct ascii_driver *a = ascii_driver_cast (driver);
379 if (is_table_item (output_item))
381 struct table_item *table_item = to_table_item (output_item);
382 const char *caption = table_item_get_caption (table_item);
383 struct render_params params;
384 struct render_page *page;
385 struct render_break x_break;
389 update_page_size (a, false);
393 /* XXX doesn't do well with very large captions */
394 struct table_cell cell;
395 ascii_init_caption_cell (caption, &cell);
396 caption_height = ascii_measure_cell_height (a, &cell, a->width);
401 params.draw_line = ascii_draw_line;
402 params.measure_cell_width = ascii_measure_cell_width;
403 params.measure_cell_height = ascii_measure_cell_height;
404 params.draw_cell = ascii_draw_cell,
406 params.size[H] = a->width;
407 params.size[V] = a->length - caption_height;
408 params.font_size[H] = 1;
409 params.font_size[V] = 1;
410 for (i = 0; i < RENDER_N_LINES; i++)
412 int width = i == RENDER_LINE_NONE ? 0 : 1;
413 params.line_widths[H][i] = width;
414 params.line_widths[V][i] = width;
417 if (a->file == NULL && !ascii_open_page (a))
420 page = render_page_create (¶ms, table_item_get_table (table_item));
421 for (render_break_init (&x_break, page, H);
422 render_break_has_next (&x_break); )
424 struct render_page *x_slice;
425 struct render_break y_break;
427 x_slice = render_break_next (&x_break, a->width);
428 for (render_break_init (&y_break, x_slice, V);
429 render_break_has_next (&y_break); )
431 struct render_page *y_slice;
437 space = a->length - a->y - caption_height;
438 if (render_break_next_size (&y_break) > space)
441 ascii_close_page (a);
442 if (!ascii_open_page (a))
447 y_slice = render_break_next (&y_break, space);
450 struct table_cell cell;
451 int bb[TABLE_N_AXES][2];
453 ascii_init_caption_cell (caption, &cell);
457 bb[V][1] = caption_height;
458 ascii_draw_cell (a, &cell, bb, bb);
459 a->y += caption_height;
462 render_page_draw (y_slice);
463 a->y += render_page_get_size (y_slice, V);
464 render_page_unref (y_slice);
466 render_break_destroy (&y_break);
468 render_break_destroy (&x_break);
470 else if (is_chart_item (output_item) && a->chart_file_name != NULL)
472 struct chart_item *chart_item = to_chart_item (output_item);
475 file_name = xr_draw_png_chart (chart_item, a->chart_file_name,
477 if (file_name != NULL)
479 struct text_item *text_item;
481 text_item = text_item_create_format (
482 TEXT_ITEM_PARAGRAPH, _("See %s for a chart."), file_name);
484 ascii_submit (driver, &text_item->output_item);
485 text_item_unref (text_item);
489 else if (is_text_item (output_item))
491 const struct text_item *text_item = to_text_item (output_item);
492 enum text_item_type type = text_item_get_type (text_item);
493 const char *text = text_item_get_text (text_item);
497 case TEXT_ITEM_TITLE:
499 a->title = xstrdup (text);
502 case TEXT_ITEM_SUBTITLE:
504 a->subtitle = xstrdup (text);
507 case TEXT_ITEM_COMMAND_CLOSE:
510 case TEXT_ITEM_BLANK_LINE:
515 case TEXT_ITEM_EJECT_PAGE:
517 ascii_close_page (a);
522 struct table_item *item;
524 item = table_item_create (table_from_string (TAB_LEFT, text),
526 ascii_submit (&a->driver, &item->output_item);
527 table_item_unref (item);
534 const struct output_driver_class ascii_class =
550 static void ascii_expand_line (struct ascii_driver *, int y, int length);
551 static void ascii_layout_cell (struct ascii_driver *,
552 const struct table_cell *,
553 int bb[TABLE_N_AXES][2],
554 int clip[TABLE_N_AXES][2], enum wrap_mode wrap,
555 int *width, int *height);
558 ascii_draw_line (void *a_, int bb[TABLE_N_AXES][2],
559 enum render_line_style styles[TABLE_N_AXES][2])
561 struct ascii_driver *a = a_;
562 unsigned short int value;
566 /* Clip to the page. */
567 if (bb[H][0] >= a->width || bb[V][0] + a->y >= a->length)
569 x1 = MIN (bb[H][1], a->width);
570 y1 = MIN (bb[V][1] + a->y, a->length);
573 value = ATTR_BOX | make_box_index (styles[V][0], styles[V][1],
574 styles[H][0], styles[H][1]);
575 for (y = bb[V][0] + a->y; y < y1; y++)
577 ascii_expand_line (a, y, x1);
578 for (x = bb[H][0]; x < x1; x++)
579 a->lines[y].chars[x] = value;
584 ascii_measure_cell_width (void *a_, const struct table_cell *cell,
585 int *min_width, int *max_width)
587 struct ascii_driver *a = a_;
588 int bb[TABLE_N_AXES][2];
589 int clip[TABLE_N_AXES][2];
596 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
597 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, max_width, &h);
599 if (strchr (cell->contents, ' '))
602 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, min_width, &h);
605 *min_width = *max_width;
609 ascii_measure_cell_height (void *a_, const struct table_cell *cell, int width)
611 struct ascii_driver *a = a_;
612 int bb[TABLE_N_AXES][2];
613 int clip[TABLE_N_AXES][2];
620 clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
621 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, &w, &h);
626 ascii_draw_cell (void *a_, const struct table_cell *cell,
627 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2])
629 struct ascii_driver *a = a_;
632 ascii_layout_cell (a, cell, bb, clip, WRAP_WORD, &w, &h);
635 /* Ensures that at least the first LENGTH characters of line Y in
636 ascii driver A have been cleared out. */
638 ascii_expand_line (struct ascii_driver *a, int y, int length)
640 struct ascii_line *line = &a->lines[y];
641 if (line->n_chars < length)
644 if (line->allocated_chars < length)
646 line->allocated_chars = MAX (length, MIN (length * 2, a->width));
647 line->chars = xnrealloc (line->chars, line->allocated_chars,
648 sizeof *line->chars);
650 for (x = line->n_chars; x < length; x++)
651 line->chars[x] = ' ';
652 line->n_chars = length;
657 text_draw (struct ascii_driver *a, const struct table_cell *cell,
658 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
659 int y, const char *string, int n)
661 int x0 = MAX (0, clip[H][0]);
662 int y0 = MAX (0, clip[V][0] + a->y);
664 int y1 = MIN (a->length, clip[V][1] + a->y);
668 if (y < y0 || y >= y1)
671 switch (cell->options & TAB_ALIGNMENT)
677 x = (bb[H][0] + bb[H][1] - n + 1) / 2;
699 int attr = cell->options & TAB_EMPH ? ATTR_EMPHASIS : 0;
702 ascii_expand_line (a, y, x + n);
703 for (i = 0; i < n; i++)
704 a->lines[y].chars[x + i] = string[i] | attr;
709 ascii_layout_cell (struct ascii_driver *a, const struct table_cell *cell,
710 int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
711 enum wrap_mode wrap, int *width, int *height)
713 size_t length = strlen (cell->contents);
718 for (y = bb[V][0]; y < bb[V][1] && pos < length; y++)
720 const char *line = &cell->contents[pos];
721 const char *new_line;
724 /* Find line length without considering word wrap. */
725 line_len = MIN (bb[H][1] - bb[H][0], length - pos);
726 new_line = memchr (line, '\n', line_len);
727 if (new_line != NULL)
728 line_len = new_line - line;
731 if (pos + line_len < length && wrap != WRAP_CHAR)
733 size_t space_len = line_len;
734 while (space_len > 0 && !isspace ((unsigned char) line[space_len]))
737 line_len = space_len;
738 else if (wrap == WRAP_WORD)
740 while (pos + line_len < length
741 && !isspace ((unsigned char) line[line_len]))
745 if (line_len > *width)
749 text_draw (a, cell, bb, clip, y, line, line_len);
753 if (pos < length && isspace ((unsigned char) cell->contents[pos]))
756 *height = y - bb[V][0];
759 /* ascii_close_page () and support routines. */
762 ascii_open_page (struct ascii_driver *a)
771 a->file = fn_open (a->file_name, a->append ? "a" : "w");
775 fputs (a->init, a->file);
779 error (0, errno, _("ascii: opening output file \"%s\""),
788 if (a->length > a->allocated_lines)
790 a->lines = xnrealloc (a->lines, a->length, sizeof *a->lines);
791 for (i = a->allocated_lines; i < a->length; i++)
793 struct ascii_line *line = &a->lines[i];
795 line->allocated_chars = 0;
797 a->allocated_lines = a->length;
800 for (i = 0; i < a->length; i++)
801 a->lines[i].n_chars = 0;
806 /* Writes LINE to A's output file. */
808 output_line (struct ascii_driver *a, const struct ascii_line *line)
813 length = line->n_chars;
814 while (length > 0 && line->chars[length - 1] == ' ')
817 for (i = 0; i < length; i++)
819 int attribute = line->chars[i] & (ATTR_BOX | ATTR_EMPHASIS);
820 int ch = line->chars[i] & ~(ATTR_BOX | ATTR_EMPHASIS);
825 fputs (a->box[ch], a->file);
829 if (a->emphasis == EMPH_BOLD)
830 fprintf (a->file, "%c\b%c", ch, ch);
831 else if (a->emphasis == EMPH_UNDERLINE)
832 fprintf (a->file, "_\b%c", ch);
843 putc ('\n', a->file);
847 output_title_line (FILE *out, int width, const char *left, const char *right)
849 struct string s = DS_EMPTY_INITIALIZER;
850 ds_put_char_multiple (&s, ' ', width);
853 size_t length = MIN (strlen (left), width);
854 memcpy (ds_end (&s) - width, left, length);
858 size_t length = MIN (strlen (right), width);
859 memcpy (ds_end (&s) - length, right, length);
861 ds_put_char (&s, '\n');
862 fputs (ds_cstr (&s), out);
867 ascii_close_page (struct ascii_driver *a)
876 if (!a->top_margin && !a->bottom_margin && a->squeeze_blank_lines
877 && !a->paginate && a->page_number > 1)
878 putc ('\n', a->file);
880 for (i = 0; i < a->top_margin; i++)
881 putc ('\n', a->file);
886 r1 = xasprintf (_("%s - Page %d"), get_start_date (), a->page_number);
887 r2 = xasprintf ("%s - %s" , version, host_system);
889 output_title_line (a->file, a->width, a->title, r1);
890 output_title_line (a->file, a->width, a->subtitle, r2);
891 putc ('\n', a->file);
898 for (y = 0; y < a->allocated_lines; y++)
900 struct ascii_line *line = &a->lines[y];
902 if (a->squeeze_blank_lines && y > 0 && line->n_chars == 0)
908 putc ('\n', a->file);
912 output_line (a, line);
915 if (!a->squeeze_blank_lines)
916 for (y = a->allocated_lines; y < a->length; y++)
917 putc ('\n', a->file);
919 for (i = 0; i < a->bottom_margin; i++)
920 putc ('\n', a->file);
922 putc ('\f', a->file);