src/output/ascii.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2007 Free Software Foundation, Inc.
   3
   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.
   8
   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.
  13
  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/>. */
  16
  17 #include <config.h>
  18
  19 #include <ctype.h>
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24
  25 #include <data/file-name.h>
  26 #include <libpspp/alloc.h>
  27 #include <libpspp/assertion.h>
  28 #include <libpspp/compiler.h>
  29 #include <libpspp/pool.h>
  30 #include <libpspp/start-date.h>
  31 #include <libpspp/version.h>
  32
  33 #include "chart.h"
  34 #include "error.h"
  35 #include "minmax.h"
  36 #include "output.h"
  37
  38 #include "gettext.h"
  39 #define _(msgid) gettext (msgid)
  40
  41 /* ASCII driver options: (defaults listed first)
  42
  43    output-file="pspp.list"
  44    append=no|yes                If output-file exists, append to it?
  45    chart-files="pspp-#.png"     Name used for charts.
  46    chart-type=png               Format of charts (use "none" to disable).
  47
  48    paginate=on|off              Formfeeds are desired?
  49    tab-width=8                  Width of a tab; 0 to not use tabs.
  50
  51    headers=on|off               Put headers at top of page?
  52    emphasis=bold|underline|none Style to use for emphasis.
  53    length=66
  54    width=130
  55    squeeze=off|on               Squeeze multiple newlines into exactly one.
  56
  57    top-margin=2
  58    bottom-margin=2
  59
  60    box[x]="strng"               Sets box character X (X in base 4: 0-3333).
  61    init="string"                Set initialization string.
  62  */
  63
  64 /* Disable messages by failed range checks. */
  65 /*#define SUPPRESS_WARNINGS 1 */
  66
  67 /* Line styles bit shifts. */
  68 enum
  69   {
  70     LNS_TOP = 0,
  71     LNS_LEFT = 2,
  72     LNS_BOTTOM = 4,
  73     LNS_RIGHT = 6,
  74
  75     LNS_COUNT = 256
  76   };
  77
  78 /* Character attributes. */
  79 #define ATTR_EMPHASIS   0x100   /* Bold-face. */
  80 #define ATTR_BOX        0x200   /* Line drawing character. */
  81
  82 /* A line of text. */
  83 struct line
  84   {
  85     unsigned short *chars;      /* Characters and attributes. */
  86     int char_cnt;               /* Length. */
  87     int char_cap;               /* Allocated bytes. */
  88   };
  89
  90 /* How to emphasize text. */
  91 enum emphasis_style
  92   {
  93     EMPH_BOLD,                  /* Overstrike for bold. */
  94     EMPH_UNDERLINE,             /* Overstrike for underlining. */
  95     EMPH_NONE                   /* No emphasis. */
  96   };
  97
  98 /* ASCII output driver extension record. */
  99 struct ascii_driver_ext
 100   {
 101     struct pool *pool;
 102
 103     /* User parameters. */
 104     bool append;                /* Append if output-file already exists? */
 105     bool headers;               /* Print headers at top of page? */
 106     bool paginate;              /* Insert formfeeds? */
 107     bool squeeze_blank_lines;   /* Squeeze multiple blank lines into one? */
 108     enum emphasis_style emphasis; /* How to emphasize text. */
 109     int tab_width;              /* Width of a tab; 0 not to use tabs. */
 110     const char *chart_type;     /* Type of charts to output; NULL for none. */
 111     const char *chart_file_name; /* Name of files used for charts. */
 112
 113     int page_length;            /* Page length before subtracting margins. */
 114     int top_margin;             /* Top margin in lines. */
 115     int bottom_margin;          /* Bottom margin in lines. */
 116
 117     char *box[LNS_COUNT];       /* Line & box drawing characters. */
 118     char *init;                 /* Device initialization string. */
 119
 120     /* Internal state. */
 121     char *file_name;            /* Output file name. */
 122     FILE *file;                 /* Output file. */
 123     int page_number;            /* Current page number. */
 124     struct line *lines;         /* Page content. */
 125     int line_cap;               /* Number of lines allocated. */
 126     int chart_cnt;              /* Number of charts so far. */
 127   };
 128
 129 static void ascii_flush (struct outp_driver *);
 130 static int get_default_box_char (size_t idx);
 131 static bool handle_option (struct outp_driver *this, const char *key,
 132                            const struct string *val);
 133
 134 static bool
 135 ascii_open_driver (struct outp_driver *this, struct substring options)
 136 {
 137   struct ascii_driver_ext *x;
 138   int i;
 139
 140   this->width = 79;
 141   this->font_height = 1;
 142   this->prop_em_width = 1;
 143   this->fixed_width = 1;
 144   for (i = 0; i < OUTP_L_COUNT; i++)
 145     this->horiz_line_width[i] = this->vert_line_width[i] = i != OUTP_L_NONE;
 146
 147   this->ext = x = pool_create_container (struct ascii_driver_ext, pool);
 148   x->append = false;
 149   x->headers = true;
 150   x->paginate = true;
 151   x->squeeze_blank_lines = false;
 152   x->emphasis = EMPH_BOLD;
 153   x->tab_width = 8;
 154   x->chart_file_name = pool_strdup (x->pool, "pspp-#.png");
 155   x->chart_type = pool_strdup (x->pool, "png");
 156   x->page_length = 66;
 157   x->top_margin = 2;
 158   x->bottom_margin = 2;
 159   for (i = 0; i < LNS_COUNT; i++)
 160     x->box[i] = NULL;
 161   x->init = NULL;
 162   x->file_name = pool_strdup (x->pool, "pspp.list");
 163   x->file = NULL;
 164   x->page_number = 0;
 165   x->lines = NULL;
 166   x->line_cap = 0;
 167   x->chart_cnt = 0;
 168
 169   if (!outp_parse_options (options, handle_option, this))
 170     goto error;
 171
 172   this->length = x->page_length - x->top_margin - x->bottom_margin - 1;
 173   if (x->headers)
 174     this->length -= 3;
 175
 176   if (this->width < 59 || this->length < 15)
 177     {
 178       error (0, 0,
 179              _("ascii: page excluding margins and headers "
 180                "must be at least 59 characters wide by 15 lines long, but as "
 181                "configured is only %d characters by %d lines"),
 182              this->width, this->length);
 183       return false;
 184     }
 185
 186   for (i = 0; i < LNS_COUNT; i++)
 187     if (x->box[i] == NULL)
 188       {
 189         char s[2];
 190         s[0] = get_default_box_char (i);
 191         s[1] = '\0';
 192         x->box[i] = pool_strdup (x->pool, s);
 193       }
 194
 195   return true;
 196
 197  error:
 198   pool_destroy (x->pool);
 199   return false;
 200 }
 201
 202 static int
 203 get_default_box_char (size_t idx)
 204 {
 205   /* Disassemble IDX into components. */
 206   unsigned top = (idx >> LNS_TOP) & 3;
 207   unsigned left = (idx >> LNS_LEFT) & 3;
 208   unsigned bottom = (idx >> LNS_BOTTOM) & 3;
 209   unsigned right = (idx >> LNS_RIGHT) & 3;
 210
 211   /* Reassemble components into nibbles in the order TLBR.
 212      This makes it easy to read the case labels. */
 213   unsigned value = (top << 12) | (left << 8) | (bottom << 4) | (right << 0);
 214   switch (value)
 215     {
 216     case 0x0000:
 217       return ' ';
 218
 219     case 0x0100: case 0x0101: case 0x0001:
 220       return '-';
 221
 222     case 0x1000: case 0x1010: case 0x0010:
 223       return '|';
 224
 225     case 0x0300: case 0x0303: case 0x0003:
 226     case 0x0200: case 0x0202: case 0x0002:
 227       return '=';
 228
 229     default:
 230       return left > 1 || top > 1 || right > 1 || bottom > 1 ? '#' : '+';
 231     }
 232 }
 233
 234 static bool
 235 ascii_close_driver (struct outp_driver *this)
 236 {
 237   struct ascii_driver_ext *x = this->ext;
 238
 239   ascii_flush (this);
 240   pool_detach_file (x->pool, x->file);
 241   pool_destroy (x->pool);
 242
 243   return true;
 244 }
 245
 246 /* Generic option types. */
 247 enum
 248   {
 249     boolean_arg,
 250     emphasis_arg,
 251     nonneg_int_arg,
 252     pos_int_arg,
 253     string_arg
 254   };
 255
 256 static const struct outp_option option_tab[] =
 257   {
 258     {"headers", boolean_arg, 0},
 259     {"paginate", boolean_arg, 1},
 260     {"squeeze", boolean_arg, 2},
 261     {"append", boolean_arg, 3},
 262
 263     {"emphasis", emphasis_arg, 0},
 264
 265     {"length", pos_int_arg, 0},
 266     {"width", pos_int_arg, 1},
 267
 268     {"top-margin", nonneg_int_arg, 0},
 269     {"bottom-margin", nonneg_int_arg, 1},
 270     {"tab-width", nonneg_int_arg, 2},
 271
 272     {"output-file", string_arg, 0},
 273     {"chart-files", string_arg, 1},
 274     {"chart-type", string_arg, 2},
 275     {"init", string_arg, 3},
 276
 277     {NULL, 0, 0},
 278   };
 279
 280 static bool
 281 handle_option (struct outp_driver *this, const char *key,
 282                const struct string *val)
 283 {
 284   struct ascii_driver_ext *x = this->ext;
 285   int subcat;
 286   const char *value;
 287
 288   value = ds_cstr (val);
 289   if (!strncmp (key, "box[", 4))
 290     {
 291       char *tail;
 292       int indx = strtol (&key[4], &tail, 4);
 293       if (*tail != ']' || indx < 0 || indx > LNS_COUNT)
 294         {
 295           error (0, 0, _("ascii: bad index value for `box' key: syntax "
 296                          "is box[INDEX], 0 <= INDEX < %d decimal, with INDEX "
 297                          "expressed in base 4"),
 298                  LNS_COUNT);
 299           return false;
 300         }
 301       if (x->box[indx] != NULL)
 302         error (0, 0, _("ascii: multiple values for %s"), key);
 303       x->box[indx] = pool_strdup (x->pool, value);
 304       return true;
 305     }
 306
 307   switch (outp_match_keyword (key, option_tab, &subcat))
 308     {
 309     case -1:
 310       error (0, 0, _("ascii: unknown parameter `%s'"), key);
 311       break;
 312     case pos_int_arg:
 313       {
 314         char *tail;
 315         int arg;
 316
 317         errno = 0;
 318         arg = strtol (value, &tail, 0);
 319         if (arg < 1 || errno == ERANGE || *tail)
 320           {
 321             error (0, 0, _("ascii: positive integer required as `%s' value"),
 322                    key);
 323             break;
 324           }
 325         switch (subcat)
 326           {
 327           case 0:
 328             x->page_length = arg;
 329             break;
 330           case 1:
 331             this->width = arg;
 332             break;
 333           default:
 334             NOT_REACHED ();
 335           }
 336       }
 337       break;
 338     case emphasis_arg:
 339       if (!strcmp (value, "bold"))
 340         x->emphasis = EMPH_BOLD;
 341       else if (!strcmp (value, "underline"))
 342         x->emphasis = EMPH_UNDERLINE;
 343       else if (!strcmp (value, "none"))
 344         x->emphasis = EMPH_NONE;
 345       else
 346         error (0, 0,
 347                _("ascii: `emphasis' value must be `bold', "
 348                  "`underline', or `none'"));
 349       break;
 350     case nonneg_int_arg:
 351       {
 352         char *tail;
 353         int arg;
 354
 355         errno = 0;
 356         arg = strtol (value, &tail, 0);
 357         if (arg < 0 || errno == ERANGE || *tail)
 358           {
 359             error (0, 0,
 360                    _("ascii: zero or positive integer required as `%s' value"),
 361                    key);
 362             break;
 363           }
 364         switch (subcat)
 365           {
 366           case 0:
 367             x->top_margin = arg;
 368             break;
 369           case 1:
 370             x->bottom_margin = arg;
 371             break;
 372           case 2:
 373             x->tab_width = arg;
 374             break;
 375           default:
 376             NOT_REACHED ();
 377           }
 378       }
 379       break;
 380     case boolean_arg:
 381       {
 382         bool setting;
 383         if (!strcmp (value, "on") || !strcmp (value, "true")
 384             || !strcmp (value, "yes") || atoi (value))
 385           setting = true;
 386         else if (!strcmp (value, "off") || !strcmp (value, "false")
 387                  || !strcmp (value, "no") || !strcmp (value, "0"))
 388           setting = false;
 389         else
 390           {
 391             error (0, 0, _("ascii: boolean value expected for `%s'"), key);
 392             return false;
 393           }
 394         switch (subcat)
 395           {
 396           case 0:
 397             x->headers = setting;
 398             break;
 399           case 1:
 400             x->paginate = setting;
 401             break;
 402           case 2:
 403             x->squeeze_blank_lines = setting;
 404             break;
 405           case 3:
 406             x->append = setting;
 407             break;
 408           default:
 409             NOT_REACHED ();
 410           }
 411       }
 412       break;
 413     case string_arg:
 414       switch (subcat)
 415         {
 416         case 0:
 417           x->file_name = pool_strdup (x->pool, value);
 418           break;
 419         case 1:
 420           if (ds_find_char (val, '#') != SIZE_MAX)
 421             x->chart_file_name = pool_strdup (x->pool, value);
 422           else
 423             error (0, 0, _("`chart-files' value must contain `#'"));
 424           break;
 425         case 2:
 426           if (value[0] != '\0')
 427             x->chart_type = pool_strdup (x->pool, value);
 428           else
 429             x->chart_type = NULL;
 430           break;
 431         case 3:
 432           x->init = pool_strdup (x->pool, value);
 433           break;
 434         }
 435       break;
 436     default:
 437       NOT_REACHED ();
 438     }
 439
 440   return true;
 441 }
 442
 443 static void
 444 ascii_open_page (struct outp_driver *this)
 445 {
 446   struct ascii_driver_ext *x = this->ext;
 447   int i;
 448
 449   if (x->file == NULL)
 450     {
 451       x->file = fn_open (x->file_name, x->append ? "a" : "w");
 452       if (x->file == NULL)
 453         {
 454           error (0, errno, _("ascii: opening output file \"%s\""),
 455                  x->file_name);
 456           return;
 457         }
 458       pool_attach_file (x->pool, x->file);
 459
 460       if (x->init != NULL)
 461         fputs (x->init, x->file);
 462     }
 463
 464   x->page_number++;
 465
 466   if (this->length > x->line_cap)
 467     {
 468       x->lines = pool_nrealloc (x->pool,
 469                                 x->lines, this->length, sizeof *x->lines);
 470       for (i = x->line_cap; i < this->length; i++)
 471         {
 472           struct line *line = &x->lines[i];
 473           line->chars = NULL;
 474           line->char_cap = 0;
 475         }
 476       x->line_cap = this->length;
 477     }
 478
 479   for (i = 0; i < this->length; i++)
 480     x->lines[i].char_cnt = 0;
 481 }
 482
 483 /* Ensures that at least the first LENGTH characters of line Y in
 484    THIS driver identified X have been cleared out. */
 485 static inline void
 486 expand_line (struct outp_driver *this, int y, int length)
 487 {
 488   struct ascii_driver_ext *ext = this->ext;
 489   struct line *line = &ext->lines[y];
 490   if (line->char_cnt < length)
 491     {
 492       int x;
 493       if (line->char_cap < length)
 494         {
 495           line->char_cap = MIN (length * 2, this->width);
 496           line->chars = pool_nrealloc (ext->pool,
 497                                        line->chars,
 498                                        line->char_cap, sizeof *line->chars);
 499         }
 500       for (x = line->char_cnt; x < length; x++)
 501         line->chars[x] = ' ';
 502       line->char_cnt = length;
 503     }
 504 }
 505
 506 static void
 507 ascii_line (struct outp_driver *this,
 508             int x0, int y0, int x1, int y1,
 509             enum outp_line_style top, enum outp_line_style left,
 510             enum outp_line_style bottom, enum outp_line_style right)
 511 {
 512   struct ascii_driver_ext *ext = this->ext;
 513   int y;
 514   unsigned short value;
 515
 516   assert (this->page_open);
 517 #if DEBUGGING
 518   if (x0 < 0 || x1 > this->width || y0 < 0 || y1 > this->length)
 519     {
 520 #if !SUPPRESS_WARNINGS
 521       printf (_("ascii: bad line (%d,%d)-(%d,%d) out of (%d,%d)\n"),
 522               x0, y0, x1, y1, this->width, this->length);
 523 #endif
 524       return;
 525     }
 526 #endif
 527
 528   value = ((left << LNS_LEFT) | (right << LNS_RIGHT)
 529            | (top << LNS_TOP) | (bottom << LNS_BOTTOM) | ATTR_BOX);
 530   for (y = y0; y < y1; y++)
 531     {
 532       int x;
 533
 534       expand_line (this, y, x1);
 535       for (x = x0; x < x1; x++)
 536         ext->lines[y].chars[x] = value;
 537     }
 538 }
 539
 540 static void
 541 ascii_submit (struct outp_driver *this UNUSED, struct som_entity *s)
 542 {
 543   extern struct som_table_class tab_table_class;
 544
 545   assert (s->class == &tab_table_class);
 546   assert (s->type == SOM_CHART);
 547 }
 548
 549 static void
 550 text_draw (struct outp_driver *this,
 551            enum outp_font font,
 552            int x, int y,
 553            enum outp_justification justification, int width,
 554            const char *string, size_t length)
 555 {
 556   struct ascii_driver_ext *ext = this->ext;
 557   unsigned short attr = font == OUTP_EMPHASIS ? ATTR_EMPHASIS : 0;
 558
 559   int line_len;
 560
 561   switch (justification)
 562     {
 563     case OUTP_LEFT:
 564       break;
 565     case OUTP_CENTER:
 566       x += (width - length + 1) / 2;
 567       break;
 568     case OUTP_RIGHT:
 569       x += width - length;
 570       break;
 571     default:
 572       NOT_REACHED ();
 573     }
 574
 575   if (y >= this->length || x >= this->width)
 576     return;
 577
 578   if (x + length > this->width)
 579     length = this->width - x;
 580
 581   line_len = x + length;
 582
 583   expand_line (this, y, line_len);
 584   while (length-- > 0)
 585     ext->lines[y].chars[x++] = *string++ | attr;
 586 }
 587
 588 /* Divides the text T->S into lines of width T->H.  Sets *WIDTH
 589    to the maximum width of a line and *HEIGHT to the number of
 590    lines, if those arguments are non-null.  Actually draws the
 591    text if DRAW is true. */
 592 static void
 593 delineate (struct outp_driver *this, const struct outp_text *text, bool draw,
 594            int *width, int *height)
 595 {
 596   int max_width;
 597   int height_left;
 598
 599   const char *cp = ss_data (text->string);
 600
 601   max_width = 0;
 602   height_left = text->v;
 603
 604   while (height_left > 0)
 605     {
 606       size_t chars_left;
 607       size_t line_len;
 608       const char *end;
 609
 610       /* Initially the line is up to text->h characters long. */
 611       chars_left = ss_end (text->string) - cp;
 612       if (chars_left == 0)
 613         break;
 614       line_len = MIN (chars_left, text->h);
 615
 616       /* A new-line terminates the line prematurely. */
 617       end = memchr (cp, '\n', line_len);
 618       if (end != NULL)
 619         line_len = end - cp;
 620
 621       /* Don't cut off words if it can be avoided. */
 622       if (cp + line_len < ss_end (text->string))
 623         {
 624           size_t space_len = line_len;
 625           while (space_len > 0 && !isspace ((unsigned char) cp[space_len]))
 626             space_len--;
 627           if (space_len > 0)
 628             line_len = space_len;
 629         }
 630
 631       /* Draw text. */
 632       if (draw)
 633         text_draw (this,
 634                    text->font,
 635                    text->x, text->y + (text->v - height_left),
 636                    text->justification, text->h,
 637                    cp, line_len);
 638
 639       /* Update. */
 640       height_left--;
 641       if (line_len > max_width)
 642         max_width = line_len;
 643
 644       /* Next line. */
 645       cp += line_len;
 646       if (cp < ss_end (text->string) && isspace ((unsigned char) *cp))
 647         cp++;
 648     }
 649
 650   if (width != NULL)
 651     *width = max_width;
 652   if (height != NULL)
 653     *height = text->v - height_left;
 654 }
 655
 656 static void
 657 ascii_text_metrics (struct outp_driver *this, const struct outp_text *t,
 658                     int *width, int *height)
 659 {
 660   delineate (this, t, false, width, height);
 661 }
 662
 663 static void
 664 ascii_text_draw (struct outp_driver *this, const struct outp_text *t)
 665 {
 666   assert (this->page_open);
 667   delineate (this, t, true, NULL, NULL);
 668 }
 669 \f
 670 /* ascii_close_page () and support routines. */
 671
 672 /* Writes the LENGTH characters in S to OUT.  */
 673 static void
 674 output_line (struct outp_driver *this, const struct line *line,
 675              struct string *out)
 676 {
 677   struct ascii_driver_ext *ext = this->ext;
 678   const unsigned short *s = line->chars;
 679   size_t length;
 680
 681   for (length = line->char_cnt; length-- > 0; s++)
 682     if (*s & ATTR_BOX)
 683       ds_put_cstr (out, ext->box[*s & 0xff]);
 684     else
 685       {
 686         if (*s & ATTR_EMPHASIS)
 687           {
 688             if (ext->emphasis == EMPH_BOLD)
 689               {
 690                 ds_put_char (out, *s);
 691                 ds_put_char (out, '\b');
 692               }
 693             else if (ext->emphasis == EMPH_UNDERLINE)
 694               ds_put_cstr (out, "_\b");
 695           }
 696         ds_put_char (out, *s);
 697       }
 698 }
 699
 700 static void
 701 append_lr_justified (struct string *out, int width,
 702                      const char *left, const char *right)
 703 {
 704   ds_put_char_multiple (out, ' ', width);
 705   if (left != NULL)
 706     {
 707       size_t length = MIN (strlen (left), width);
 708       memcpy (ds_end (out) - width, left, length);
 709     }
 710   if (right != NULL)
 711     {
 712       size_t length = MIN (strlen (right), width);
 713       memcpy (ds_end (out) - length, right, length);
 714     }
 715   ds_put_char (out, '\n');
 716 }
 717
 718 static void
 719 dump_output (struct outp_driver *this, struct string *out)
 720 {
 721   struct ascii_driver_ext *x = this->ext;
 722   fwrite (ds_data (out), ds_length (out), 1, x->file);
 723   ds_clear (out);
 724 }
 725
 726 static void
 727 ascii_close_page (struct outp_driver *this)
 728 {
 729   struct ascii_driver_ext *x = this->ext;
 730   struct string out;
 731   int line_num;
 732
 733   if (x->file == NULL)
 734     return;
 735
 736   ds_init_empty (&out);
 737
 738   ds_put_char_multiple (&out, '\n', x->top_margin);
 739   if (x->headers)
 740     {
 741       char *r1, *r2;
 742
 743       r1 = xasprintf (_("%s - Page %d"), get_start_date (), x->page_number);
 744       r2 = xasprintf ("%s - %s" , version, host_system);
 745
 746       append_lr_justified (&out, this->width, outp_title, r1);
 747       append_lr_justified (&out, this->width, outp_subtitle, r2);
 748       ds_put_char (&out, '\n');
 749
 750       free (r1);
 751       free (r2);
 752     }
 753   dump_output (this, &out);
 754
 755   for (line_num = 0; line_num < this->length; line_num++)
 756     {
 757
 758       /* Squeeze multiple blank lines into a single blank line if
 759          requested. */
 760       if (x->squeeze_blank_lines)
 761         {
 762           if (line_num >= x->line_cap)
 763             break;
 764           if (line_num > 0
 765               && x->lines[line_num].char_cnt == 0
 766               && x->lines[line_num - 1].char_cnt == 0)
 767             continue;
 768         }
 769
 770       if (line_num < x->line_cap)
 771         output_line (this, &x->lines[line_num], &out);
 772       ds_put_char (&out, '\n');
 773       dump_output (this, &out);
 774     }
 775
 776   ds_put_char_multiple (&out, '\n', x->bottom_margin);
 777   if (x->paginate)
 778     ds_put_char (&out, '\f');
 779
 780   dump_output (this, &out);
 781   ds_destroy (&out);
 782 }
 783
 784 /* Flushes all output to the user and lets the user deal with it.
 785    This is applied only to output drivers that are designated as
 786    "screen" drivers that the user is interacting with in real
 787    time. */
 788 static void
 789 ascii_flush (struct outp_driver *this)
 790 {
 791   struct ascii_driver_ext *x = this->ext;
 792   if (x->file != NULL)
 793     {
 794       if (fn_close (x->file_name, x->file) != 0)
 795         error (0, errno, _("ascii: closing output file \"%s\""),
 796                x->file_name);
 797       pool_detach_file (x->pool, x->file);
 798       x->file = NULL;
 799     }
 800 }
 801
 802 static void
 803 ascii_chart_initialise (struct outp_driver *this, struct chart *ch)
 804 {
 805   struct ascii_driver_ext *x = this->ext;
 806   struct outp_text t;
 807   char *text;
 808
 809   if (x->chart_type == NULL)
 810     return;
 811
 812   /* Initialize chart. */
 813   chart_init_separate (ch, x->chart_type, x->chart_file_name, ++x->chart_cnt);
 814   if (ch->file_name == NULL)
 815     return;
 816
 817   /* Mention chart in output.
 818      First advance current position. */
 819   if (!this->page_open)
 820     outp_open_page (this);
 821   else
 822     {
 823       this->cp_y++;
 824       if (this->cp_y >= this->length)
 825         {
 826           outp_close_page (this);
 827           outp_open_page (this);
 828         }
 829     }
 830
 831   /* Then write the text. */
 832   text = xasprintf ("See %s for a chart.", ch->file_name);
 833   t.font = OUTP_FIXED;
 834   t.justification = OUTP_LEFT;
 835   t.string = ss_cstr (text);
 836   t.h = this->width;
 837   t.v = 1;
 838   t.x = 0;
 839   t.y = this->cp_y;
 840   ascii_text_draw (this, &t);
 841   this->cp_y++;
 842
 843   free (text);
 844 }
 845
 846 static void
 847 ascii_chart_finalise (struct outp_driver *this, struct chart *ch)
 848 {
 849   struct ascii_driver_ext *x = this->ext;
 850   if (x->chart_type != NULL)
 851     chart_finalise_separate (ch);
 852 }
 853
 854 const struct outp_class ascii_class =
 855 {
 856   "ascii",
 857   0,
 858
 859   ascii_open_driver,
 860   ascii_close_driver,
 861
 862   ascii_open_page,
 863   ascii_close_page,
 864   ascii_flush,
 865
 866   ascii_submit,
 867
 868   ascii_line,
 869   ascii_text_metrics,
 870   ascii_text_draw,
 871
 872   ascii_chart_initialise,
 873   ascii_chart_finalise
 874 };