src/ascii.c

   1 /* PSPP - computes sample statistics.
   2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18    02111-1307, USA. */
  19
  20 #include <config.h>
  21 #include <assert.h>
  22 #include <ctype.h>
  23 #include <errno.h>
  24 #include <limits.h>
  25 #include <stdlib.h>
  26 #include "alloc.h"
  27 #include "error.h"
  28 #include "filename.h"
  29 #include "main.h"
  30 #include "misc.h"
  31 #include "output.h"
  32 #include "pool.h"
  33 #include "version.h"
  34
  35 /* ASCII driver options: (defaults listed first)
  36
  37    output-file="pspp.list"
  38    char-set=ascii|latin1
  39    form-feed-string="\f"        Written as a formfeed.
  40    newline-string=default|"\r\n"|"\n"
  41                                 Written as a newline.
  42    paginate=on|off              Formfeeds are desired?
  43    tab-width=8                  Width of a tab; 0 to not use tabs.
  44    init=""                      Written at beginning of output.
  45    done=""                      Written at end of output.
  46
  47    headers=on|off               Put headers at top of page?
  48    length=66
  49    width=130
  50    lpi=6                        Only used to determine font size.
  51    cpi=10
  52
  53    left-margin=0
  54    right-margin=0
  55    top-margin=2
  56    bottom-margin=2
  57
  58    box[x]="strng"               Sets box character X (X in base 4: 0-3333).
  59    italic-on=overstrike|"strng" Turns on italic (underline).
  60    italic-off=""|"strng"        Turns off italic; ignored for overstrike.
  61    bold-on=overstrike|"strng"   Turns on bold.
  62    bold-off=""|"strng"          Turns off bold; ignored for overstrike.
  63    bold-italic-on=overstrike|"strng" Turns on bold-italic.
  64    bold-italic-off=""|"strng"   Turns off bold-italic; ignored for overstrike.
  65    overstrike-style=single|line Can we print a whole line then BS over it, or
  66    must we go char by char, as on a terminal?
  67    carriage-return-style=bs|cr  Must we return the carriage with a sequence of
  68    BSes, or will a single CR do it?
  69  */
  70
  71 /* Disable messages by failed range checks. */
  72 /*#define SUPPRESS_WARNINGS 1 */
  73
  74 /* Character set. */
  75 enum
  76   {
  77     CHS_ASCII,                  /* 7-bit ASCII */
  78     CHS_LATIN1                  /* Latin 1; not really supported at the moment */
  79   };
  80
  81 /* Overstrike style. */
  82 enum
  83   {
  84     OVS_SINGLE,                 /* Overstrike each character: "a\b_b\b_c\b_" */
  85     OVS_LINE                    /* Overstrike lines: "abc\b\b\b___" (or if
  86                                    newline is "\r\n", then "abc\r___").  Easier
  87                                    on the printer, doesn't work on a tty. */
  88   };
  89
  90 /* Basic output strings. */
  91 enum
  92   {
  93     OPS_INIT,                   /* Document initialization string. */
  94     OPS_DONE,                   /* Document uninit string. */
  95     OPS_FORMFEED,               /* Formfeed string. */
  96     OPS_NEWLINE,                /* Newline string. */
  97
  98     OPS_COUNT                   /* Number of output strings. */
  99   };
 100
 101 /* Line styles bit shifts. */
 102 enum
 103   {
 104     LNS_TOP = 0,
 105     LNS_LEFT = 2,
 106     LNS_BOTTOM = 4,
 107     LNS_RIGHT = 6,
 108
 109     LNS_COUNT = 256
 110   };
 111
 112 /* Carriage return style. */
 113 enum
 114   {
 115     CRS_BS,                     /* Multiple backspaces. */
 116     CRS_CR                      /* Single carriage return. */
 117   };
 118
 119 /* Assembles a byte from four taystes. */
 120 #define TAYSTE2BYTE(T, L, B, R)                 \
 121         (((T) << LNS_TOP)                       \
 122          | ((L) << LNS_LEFT)                    \
 123          | ((B) << LNS_BOTTOM)                  \
 124          | ((R) << LNS_RIGHT))
 125
 126 /* Extract tayste with shift value S from byte B. */
 127 #define BYTE2TAYSTE(B, S)                       \
 128         (((B) >> (S)) & 3)
 129
 130 /* Font style; take one of the first group |'d with one of the second group. */
 131 enum
 132   {
 133     FSTY_ON = 000,              /* Turn font on. */
 134     FSTY_OFF = 001,             /* Turn font off. */
 135
 136     FSTY_ITALIC = 0,            /* Italic font. */
 137     FSTY_BOLD = 2,              /* Bold font. */
 138     FSTY_BOLD_ITALIC = 4,       /* Bold-italic font. */
 139
 140     FSTY_COUNT = 6              /* Number of font styles. */
 141   };
 142
 143 /* ASCII output driver extension record. */
 144 struct ascii_driver_ext
 145   {
 146     /* User parameters. */
 147     int char_set;               /* CHS_ASCII/CHS_LATIN1; no-op right now. */
 148     int headers;                /* 1=print headers at top of page. */
 149     int page_length;            /* Page length in lines. */
 150     int page_width;             /* Page width in characters. */
 151     int lpi;                    /* Lines per inch. */
 152     int cpi;                    /* Characters per inch. */
 153     int left_margin;            /* Left margin in characters. */
 154     int right_margin;           /* Right margin in characters. */
 155     int top_margin;             /* Top margin in lines. */
 156     int bottom_margin;          /* Bottom margin in lines. */
 157     int paginate;               /* 1=insert formfeeds. */
 158     int tab_width;              /* Width of a tab; 0 not to use tabs. */
 159     struct len_string ops[OPS_COUNT]; /* Basic output strings. */
 160     struct len_string box[LNS_COUNT]; /* Line & box drawing characters. */
 161     struct len_string fonts[FSTY_COUNT]; /* Font styles; NULL=overstrike. */
 162     int overstrike_style;       /* OVS_SINGLE or OVS_LINE. */
 163     int carriage_return_style;  /* Carriage return style. */
 164
 165     /* Internal state. */
 166     struct file_ext file;       /* Output file. */
 167     int page_number;            /* Current page number. */
 168     unsigned short *page;       /* Page content. */
 169     int page_size;              /* Number of bytes allocated for page, attr. */
 170     int *line_len;              /* Length of each line in page, attr. */
 171     int line_len_size;          /* Number of ints allocated for line_len. */
 172     int w, l;                   /* Actual width & length w/o margins, etc. */
 173     int n_output;               /* Number of lines output so far. */
 174     int cur_font;               /* Current font by OUTP_F_*. */
 175 #if GLOBAL_DEBUGGING
 176     int debug;                  /* Set by som_text_draw(). */
 177 #endif
 178   };
 179
 180 static struct pool *ascii_pool;
 181
 182 static int postopen (struct file_ext *);
 183 static int preclose (struct file_ext *);
 184
 185 int
 186 ascii_open_global (struct outp_class *this unused)
 187 {
 188   ascii_pool = pool_create ();
 189   return 1;
 190 }
 191
 192 int
 193 ascii_close_global (struct outp_class *this unused)
 194 {
 195   pool_destroy (ascii_pool);
 196   return 1;
 197 }
 198
 199 int *
 200 ascii_font_sizes (struct outp_class *this unused, int *n_valid_sizes)
 201 {
 202   static int valid_sizes[] = {12, 12, 0, 0};
 203
 204   assert (n_valid_sizes);
 205   *n_valid_sizes = 1;
 206   return valid_sizes;
 207 }
 208
 209 int
 210 ascii_preopen_driver (struct outp_driver *this)
 211 {
 212   struct ascii_driver_ext *x;
 213   int i;
 214
 215   assert (this->driver_open == 0);
 216   msg (VM (1), _("ASCII driver initializing as `%s'..."), this->name);
 217   this->ext = x = xmalloc (sizeof (struct ascii_driver_ext));
 218   x->char_set = CHS_ASCII;
 219   x->headers = 1;
 220   x->page_length = 66;
 221   x->page_width = 79;
 222   x->lpi = 6;
 223   x->cpi = 10;
 224   x->left_margin = 0;
 225   x->right_margin = 0;
 226   x->top_margin = 2;
 227   x->bottom_margin = 2;
 228   x->paginate = 1;
 229   x->tab_width = 8;
 230   for (i = 0; i < OPS_COUNT; i++)
 231     ls_null (&x->ops[i]);
 232   for (i = 0; i < LNS_COUNT; i++)
 233     ls_null (&x->box[i]);
 234   for (i = 0; i < FSTY_COUNT; i++)
 235     ls_null (&x->fonts[i]);
 236   x->overstrike_style = OVS_SINGLE;
 237   x->carriage_return_style = CRS_BS;
 238   x->file.filename = NULL;
 239   x->file.mode = "wb";
 240   x->file.file = NULL;
 241   x->file.sequence_no = &x->page_number;
 242   x->file.param = x;
 243   x->file.postopen = postopen;
 244   x->file.preclose = preclose;
 245   x->page_number = 0;
 246   x->page = NULL;
 247   x->page_size = 0;
 248   x->line_len = NULL;
 249   x->line_len_size = 0;
 250   x->n_output = 0;
 251   x->cur_font = OUTP_F_R;
 252 #if GLOBAL_DEBUGGING
 253   x->debug = 0;
 254 #endif
 255   return 1;
 256 }
 257
 258 int
 259 ascii_postopen_driver (struct outp_driver *this)
 260 {
 261   struct ascii_driver_ext *x = this->ext;
 262
 263   assert (this->driver_open == 0);
 264
 265   if (NULL == x->file.filename)
 266     x->file.filename = xstrdup ("pspp.list");
 267
 268   x->w = x->page_width - x->left_margin - x->right_margin;
 269   x->l = (x->page_length - (x->headers ? 3 : 0) - x->top_margin
 270           - x->bottom_margin - 1);
 271   if (x->w < 59 || x->l < 15)
 272     {
 273       msg (SE, _("ascii driver: Area of page excluding margins and headers "
 274                  "must be at least 59 characters wide by 15 lines long.  Page as "
 275                  "configured is only %d characters by %d lines."), x->w, x->l);
 276       return 0;
 277     }
 278
 279   this->res = x->lpi * x->cpi;
 280   this->horiz = x->lpi;
 281   this->vert = x->cpi;
 282   this->width = x->w * this->horiz;
 283   this->length = x->l * this->vert;
 284
 285   if (ls_null_p (&x->ops[OPS_FORMFEED]))
 286     ls_create (ascii_pool, &x->ops[OPS_FORMFEED], "\f");
 287   if (ls_null_p (&x->ops[OPS_NEWLINE])
 288       || !strcmp (ls_value (&x->ops[OPS_NEWLINE]), "default"))
 289     {
 290       ls_create (ascii_pool, &x->ops[OPS_NEWLINE], "\n");
 291       x->file.mode = "wt";
 292     }
 293
 294   {
 295     int i;
 296
 297     for (i = 0; i < LNS_COUNT; i++)
 298       {
 299         char c[2];
 300         c[1] = 0;
 301         if (!ls_null_p (&x->box[i]))
 302           continue;
 303         switch (i)
 304           {
 305           case TAYSTE2BYTE (0, 0, 0, 0):
 306             c[0] = ' ';
 307             break;
 308
 309           case TAYSTE2BYTE (0, 1, 0, 0):
 310           case TAYSTE2BYTE (0, 1, 0, 1):
 311           case TAYSTE2BYTE (0, 0, 0, 1):
 312             c[0] = '-';
 313             break;
 314
 315           case TAYSTE2BYTE (1, 0, 0, 0):
 316           case TAYSTE2BYTE (1, 0, 1, 0):
 317           case TAYSTE2BYTE (0, 0, 1, 0):
 318             c[0] = '|';
 319             break;
 320
 321           case TAYSTE2BYTE (0, 3, 0, 0):
 322           case TAYSTE2BYTE (0, 3, 0, 3):
 323           case TAYSTE2BYTE (0, 0, 0, 3):
 324           case TAYSTE2BYTE (0, 2, 0, 0):
 325           case TAYSTE2BYTE (0, 2, 0, 2):
 326           case TAYSTE2BYTE (0, 0, 0, 2):
 327             c[0] = '=';
 328             break;
 329
 330           case TAYSTE2BYTE (3, 0, 0, 0):
 331           case TAYSTE2BYTE (3, 0, 3, 0):
 332           case TAYSTE2BYTE (0, 0, 3, 0):
 333           case TAYSTE2BYTE (2, 0, 0, 0):
 334           case TAYSTE2BYTE (2, 0, 2, 0):
 335           case TAYSTE2BYTE (0, 0, 2, 0):
 336             c[0] = '#';
 337             break;
 338
 339           default:
 340             if (BYTE2TAYSTE (i, LNS_LEFT) > 1
 341                 || BYTE2TAYSTE (i, LNS_TOP) > 1
 342                 || BYTE2TAYSTE (i, LNS_RIGHT) > 1
 343                 || BYTE2TAYSTE (i, LNS_BOTTOM) > 1)
 344               c[0] = '#';
 345             else
 346               c[0] = '+';
 347             break;
 348           }
 349         ls_create (ascii_pool, &x->box[i], c);
 350       }
 351   }
 352
 353   {
 354     int i;
 355
 356     this->cp_x = this->cp_y = 0;
 357     this->font_height = this->vert;
 358     this->prop_em_width = this->horiz;
 359     this->fixed_width = this->horiz;
 360
 361     this->horiz_line_width[0] = 0;
 362     this->vert_line_width[0] = 0;
 363
 364     for (i = 1; i < OUTP_L_COUNT; i++)
 365       {
 366         this->horiz_line_width[i] = this->vert;
 367         this->vert_line_width[i] = this->horiz;
 368       }
 369
 370     for (i = 0; i < (1 << OUTP_L_COUNT); i++)
 371       {
 372         this->horiz_line_spacing[i] = (i & ~1) ? this->vert : 0;
 373         this->vert_line_spacing[i] = (i & ~1) ? this->horiz : 0;
 374       }
 375   }
 376
 377   this->driver_open = 1;
 378   msg (VM (2), _("%s: Initialization complete."), this->name);
 379
 380   return 1;
 381 }
 382
 383 int
 384 ascii_close_driver (struct outp_driver *this)
 385 {
 386   struct ascii_driver_ext *x = this->ext;
 387
 388   assert (this->driver_open == 1);
 389   msg (VM (2), _("%s: Beginning closing..."), this->name);
 390
 391   x = this->ext;
 392   free (x->page);
 393   free (x->line_len);
 394   fn_close_ext (&x->file);
 395   free (x->file.filename);
 396   free (x);
 397
 398   this->driver_open = 0;
 399   msg (VM (3), _("%s: Finished closing."), this->name);
 400
 401   return 1;
 402 }
 403
 404 /* Generic option types. */
 405 enum
 406   {
 407     pos_int_arg = -10,
 408     nonneg_int_arg,
 409     string_arg,
 410     font_string_arg,
 411     boolean_arg
 412   };
 413
 414 static struct outp_option option_tab[] =
 415   {
 416     {"headers", boolean_arg, 0},
 417     {"output-file", 1, 0},
 418     {"char-set", 2, 0},
 419     {"length", pos_int_arg, 0},
 420     {"width", pos_int_arg, 1},
 421     {"lpi", pos_int_arg, 2},
 422     {"cpi", pos_int_arg, 3},
 423     {"init", string_arg, 0},
 424     {"done", string_arg, 1},
 425     {"left-margin", nonneg_int_arg, 0},
 426     {"right-margin", nonneg_int_arg, 1},
 427     {"top-margin", nonneg_int_arg, 2},
 428     {"bottom-margin", nonneg_int_arg, 3},
 429     {"paginate", boolean_arg, 1},
 430     {"form-feed-string", string_arg, 2},
 431     {"newline-string", string_arg, 3},
 432     {"italic-on", font_string_arg, 0},
 433     {"italic-off", font_string_arg, 1},
 434     {"bold-on", font_string_arg, 2},
 435     {"bold-off", font_string_arg, 3},
 436     {"bold-italic-on", font_string_arg, 4},
 437     {"bold-italic-off", font_string_arg, 5},
 438     {"overstrike-style", 3, 0},
 439     {"tab-width", nonneg_int_arg, 4},
 440     {"carriage-return-style", 4, 0},
 441     {"", 0, 0},
 442   };
 443 static struct outp_option_info option_info;
 444
 445 void
 446 ascii_option (struct outp_driver *this, const char *key,
 447               const struct string *val)
 448 {
 449   struct ascii_driver_ext *x = this->ext;
 450   int cat, subcat;
 451   const char *value;
 452
 453   value = ds_value (val);
 454   if (!strncmp (key, "box[", 4))
 455     {
 456       char *tail;
 457       int indx = strtol (&key[4], &tail, 4);
 458       if (*tail != ']' || indx < 0 || indx > LNS_COUNT)
 459         {
 460           msg (SE, _("Bad index value for `box' key: syntax is box[INDEX], "
 461                "0 <= INDEX < %d decimal, with INDEX expressed in base 4."),
 462                LNS_COUNT);
 463           return;
 464         }
 465       if (!ls_null_p (&x->box[indx]))
 466         msg (SW, _("Duplicate value for key `%s'."), key);
 467       ls_create (ascii_pool, &x->box[indx], value);
 468       return;
 469     }
 470
 471   cat = outp_match_keyword (key, option_tab, &option_info, &subcat);
 472
 473   switch (cat)
 474     {
 475     case 0:
 476       msg (SE, _("Unknown configuration parameter `%s' for ascii device driver."),
 477            key);
 478       break;
 479     case 1:
 480       free (x->file.filename);
 481       x->file.filename = xstrdup (value);
 482       break;
 483     case 2:
 484       if (!strcmp (value, "ascii"))
 485         x->char_set = CHS_ASCII;
 486       else if (!strcmp (value, "latin1"))
 487         x->char_set = CHS_LATIN1;
 488       else
 489         msg (SE, _("Unknown character set `%s'.  Valid character sets are "
 490              "`ascii' and `latin1'."), value);
 491       break;
 492     case 3:
 493       if (!strcmp (value, "single"))
 494         x->overstrike_style = OVS_SINGLE;
 495       else if (!strcmp (value, "line"))
 496         x->overstrike_style = OVS_LINE;
 497       else
 498         msg (SE, _("Unknown overstrike style `%s'.  Valid overstrike styles "
 499              "are `single' and `line'."), value);
 500       break;
 501     case 4:
 502       if (!strcmp (value, "bs"))
 503         x->carriage_return_style = CRS_BS;
 504       else if (!strcmp (value, "cr"))
 505         x->carriage_return_style = CRS_CR;
 506       else
 507         msg (SE, _("Unknown carriage return style `%s'.  Valid carriage "
 508              "return styles are `cr' and `bs'."), value);
 509       break;
 510     case pos_int_arg:
 511       {
 512         char *tail;
 513         int arg;
 514
 515         errno = 0;
 516         arg = strtol (value, &tail, 0);
 517         if (arg < 1 || errno == ERANGE || *tail)
 518           {
 519             msg (SE, _("Positive integer required as value for `%s'."), key);
 520             break;
 521           }
 522         switch (subcat)
 523           {
 524           case 0:
 525             x->page_length = arg;
 526             break;
 527           case 1:
 528             x->page_width = arg;
 529             break;
 530           case 2:
 531             x->lpi = arg;
 532             break;
 533           case 3:
 534             x->cpi = arg;
 535             break;
 536           default:
 537             assert (0);
 538           }
 539       }
 540       break;
 541     case nonneg_int_arg:
 542       {
 543         char *tail;
 544         int arg;
 545
 546         errno = 0;
 547         arg = strtol (value, &tail, 0);
 548         if (arg < 0 || errno == ERANGE || *tail)
 549           {
 550             msg (SE, _("Zero or positive integer required as value for `%s'."),
 551                  key);
 552             break;
 553           }
 554         switch (subcat)
 555           {
 556           case 0:
 557             x->left_margin = arg;
 558             break;
 559           case 1:
 560             x->right_margin = arg;
 561             break;
 562           case 2:
 563             x->top_margin = arg;
 564             break;
 565           case 3:
 566             x->bottom_margin = arg;
 567             break;
 568           case 4:
 569             x->tab_width = arg;
 570             break;
 571           default:
 572             assert (0);
 573           }
 574       }
 575       break;
 576     case string_arg:
 577       {
 578         struct len_string *s;
 579         switch (subcat)
 580           {
 581           case 0:
 582             s = &x->ops[OPS_INIT];
 583             break;
 584           case 1:
 585             s = &x->ops[OPS_DONE];
 586             break;
 587           case 2:
 588             s = &x->ops[OPS_FORMFEED];
 589             break;
 590           case 3:
 591             s = &x->ops[OPS_NEWLINE];
 592             break;
 593           default:
 594             assert (0);
 595           }
 596         ls_create (ascii_pool, s, value);
 597       }
 598       break;
 599     case font_string_arg:
 600       {
 601         if (!strcmp (value, "overstrike"))
 602           {
 603             ls_destroy (ascii_pool, &x->fonts[subcat]);
 604             return;
 605           }
 606         ls_create (ascii_pool, &x->fonts[subcat], value);
 607       }
 608       break;
 609     case boolean_arg:
 610       {
 611         int setting;
 612         if (!strcmp (value, "on") || !strcmp (value, "true")
 613             || !strcmp (value, "yes") || atoi (value))
 614           setting = 1;
 615         else if (!strcmp (value, "off") || !strcmp (value, "false")
 616                  || !strcmp (value, "no") || !strcmp (value, "0"))
 617           setting = 0;
 618         else
 619           {
 620             msg (SE, _("Boolean value expected for %s."), key);
 621             return;
 622           }
 623         switch (subcat)
 624           {
 625           case 0:
 626             x->headers = 0;
 627             break;
 628           case 1:
 629             x->paginate = setting;
 630             break;
 631           default:
 632             assert (0);
 633           }
 634       }
 635       break;
 636     default:
 637       assert (0);
 638     }
 639 }
 640
 641 int
 642 postopen (struct file_ext *f)
 643 {
 644   struct ascii_driver_ext *x = f->param;
 645   struct len_string *s = &x->ops[OPS_INIT];
 646
 647   if (!ls_empty_p (s) && fwrite (ls_value (s), ls_length (s), 1, f->file) < 1)
 648     {
 649       msg (ME, _("ASCII output driver: %s: %s"),
 650            f->filename, strerror (errno));
 651       return 0;
 652     }
 653   return 1;
 654 }
 655
 656 int
 657 preclose (struct file_ext *f)
 658 {
 659   struct ascii_driver_ext *x = f->param;
 660   struct len_string *d = &x->ops[OPS_DONE];
 661
 662   if (!ls_empty_p (d) && fwrite (ls_value (d), ls_length (d), 1, f->file) < 1)
 663     {
 664       msg (ME, _("ASCII output driver: %s: %s"),
 665            f->filename, strerror (errno));
 666       return 0;
 667     }
 668   return 1;
 669 }
 670
 671 int
 672 ascii_open_page (struct outp_driver *this)
 673 {
 674   struct ascii_driver_ext *x = this->ext;
 675   int req_page_size;
 676
 677   assert (this->driver_open && !this->page_open);
 678   x->page_number++;
 679   if (!fn_open_ext (&x->file))
 680     {
 681       msg (ME, _("ASCII output driver: %s: %s"), x->file.filename,
 682            strerror (errno));
 683       return 0;
 684     }
 685
 686   req_page_size = x->w * x->l;
 687   if (req_page_size > x->page_size || req_page_size / 2 < x->page_size)
 688     {
 689       x->page_size = req_page_size;
 690       x->page = xrealloc (x->page, sizeof *x->page * req_page_size);
 691     }
 692
 693   if (x->l > x->line_len_size)
 694     {
 695       x->line_len_size = x->l;
 696       x->line_len = xrealloc (x->line_len,
 697                               sizeof *x->line_len * x->line_len_size);
 698     }
 699
 700   memset (x->line_len, 0, sizeof *x->line_len * x->l);
 701
 702   this->page_open = 1;
 703   return 1;
 704 }
 705
 706 /* Ensures that at least the first L characters of line I in the
 707    driver identified by struct ascii_driver_ext *X have been cleared out. */
 708 static inline void
 709 expand_line (struct ascii_driver_ext *x, int i, int l)
 710 {
 711   int limit = i * x->w + l;
 712   int j;
 713
 714   for (j = i * x->w + x->line_len[i]; j < limit; j++)
 715     x->page[j] = ' ';
 716   x->line_len[i] = l;
 717 }
 718
 719 /* Puts line L at (H,K) in the current output page.  Assumes
 720    struct ascii_driver_ext named `ext'. */
 721 #define draw_line(H, K, L)                              \
 722         ext->page[ext->w * (K) + (H)] = (L) | 0x800
 723
 724 /* Line styles for each position. */
 725 #define T(STYLE) (STYLE<<LNS_TOP)
 726 #define L(STYLE) (STYLE<<LNS_LEFT)
 727 #define B(STYLE) (STYLE<<LNS_BOTTOM)
 728 #define R(STYLE) (STYLE<<LNS_RIGHT)
 729
 730 void
 731 ascii_line_horz (struct outp_driver *this, const struct rect *r,
 732                  const struct color *c unused, int style)
 733 {
 734   struct ascii_driver_ext *ext = this->ext;
 735   int x1 = r->x1 / this->horiz;
 736   int x2 = r->x2 / this->horiz;
 737   int y1 = r->y1 / this->vert;
 738   int x;
 739
 740   assert (this->driver_open && this->page_open);
 741   if (x1 == x2)
 742     return;
 743 #if GLOBAL_DEBUGGING
 744   if (x1 > x2
 745       || x1 < 0 || x1 >= ext->w
 746       || x2 <= 0 || x2 > ext->w
 747       || y1 < 0 || y1 >= ext->l)
 748     {
 749 #if !SUPPRESS_WARNINGS
 750       printf (_("ascii_line_horz: bad hline (%d,%d),%d out of (%d,%d)\n"),
 751               x1, x2, y1, ext->w, ext->l);
 752 #endif
 753       return;
 754     }
 755 #endif
 756
 757   if (ext->line_len[y1] < x2)
 758     expand_line (ext, y1, x2);
 759
 760   for (x = x1; x < x2; x++)
 761     draw_line (x, y1, (style << LNS_LEFT) | (style << LNS_RIGHT));
 762 }
 763
 764 void
 765 ascii_line_vert (struct outp_driver *this, const struct rect *r,
 766                  const struct color *c unused, int style)
 767 {
 768   struct ascii_driver_ext *ext = this->ext;
 769   int x1 = r->x1 / this->horiz;
 770   int y1 = r->y1 / this->vert;
 771   int y2 = r->y2 / this->vert;
 772   int y;
 773
 774   assert (this->driver_open && this->page_open);
 775   if (y1 == y2)
 776     return;
 777 #if GLOBAL_DEBUGGING
 778   if (y1 > y2
 779       || x1 < 0 || x1 >= ext->w
 780       || y1 < 0 || y1 >= ext->l
 781       || y2 < 0 || y2 > ext->l)
 782     {
 783 #if !SUPPRESS_WARNINGS
 784       printf (_("ascii_line_vert: bad vline %d,(%d,%d) out of (%d,%d)\n"),
 785               x1, y1, y2, ext->w, ext->l);
 786 #endif
 787       return;
 788     }
 789 #endif
 790
 791   for (y = y1; y < y2; y++)
 792     if (ext->line_len[y] <= x1)
 793       expand_line (ext, y, x1 + 1);
 794
 795   for (y = y1; y < y2; y++)
 796     draw_line (x1, y, (style << LNS_TOP) | (style << LNS_BOTTOM));
 797 }
 798
 799 void
 800 ascii_line_intersection (struct outp_driver *this, const struct rect *r,
 801                          const struct color *c unused,
 802                          const struct outp_styles *style)
 803 {
 804   struct ascii_driver_ext *ext = this->ext;
 805   int x = r->x1 / this->horiz;
 806   int y = r->y1 / this->vert;
 807   int l;
 808
 809   assert (this->driver_open && this->page_open);
 810 #if GLOBAL_DEBUGGING
 811   if (x < 0 || x >= ext->w || y < 0 || y >= ext->l)
 812     {
 813 #if !SUPPRESS_WARNINGS
 814       printf (_("ascii_line_intersection: bad intsct (%d,%d) out of (%d,%d)\n"),
 815               x, y, ext->w, ext->l);
 816 #endif
 817       return;
 818     }
 819 #endif
 820
 821   l = ((style->l << LNS_LEFT) | (style->r << LNS_RIGHT)
 822        | (style->t << LNS_TOP) | (style->b << LNS_BOTTOM));
 823
 824   if (ext->line_len[y] <= x)
 825     expand_line (ext, y, x + 1);
 826   draw_line (x, y, l);
 827 }
 828
 829 void
 830 ascii_line_width (struct outp_driver *this, int *width, int *height)
 831 {
 832   int i;
 833
 834   assert (this->driver_open && this->page_open);
 835   width[0] = height[0] = 0;
 836   for (i = 1; i < OUTP_L_COUNT; i++)
 837     {
 838       width[i] = this->horiz;
 839       height[i] = this->vert;
 840     }
 841 }
 842
 843 /* FIXME: Later we could set this up so that for certain devices it
 844    performs shading? */
 845 void
 846 ascii_box (struct outp_driver *this unused, const struct rect *r unused,
 847            const struct color *bord unused, const struct color *fill unused)
 848 {
 849   assert (this->driver_open && this->page_open);
 850 }
 851
 852 /* Polylines not supported. */
 853 void
 854 ascii_polyline_begin (struct outp_driver *this unused, const struct color *c unused)
 855 {
 856   assert (this->driver_open && this->page_open);
 857 }
 858 void
 859 ascii_polyline_point (struct outp_driver *this unused, int x unused, int y unused)
 860 {
 861   assert (this->driver_open && this->page_open);
 862 }
 863 void
 864 ascii_polyline_end (struct outp_driver *this unused)
 865 {
 866   assert (this->driver_open && this->page_open);
 867 }
 868
 869 void
 870 ascii_text_set_font_by_name (struct outp_driver * this, const char *s)
 871 {
 872   struct ascii_driver_ext *x = this->ext;
 873   int len = strlen (s);
 874
 875   assert (this->driver_open && this->page_open);
 876   x->cur_font = OUTP_F_R;
 877   if (len == 0)
 878     return;
 879   if (s[len - 1] == 'I')
 880     {
 881       if (len > 1 && s[len - 2] == 'B')
 882         x->cur_font = OUTP_F_BI;
 883       else
 884         x->cur_font = OUTP_F_I;
 885     }
 886   else if (s[len - 1] == 'B')
 887     x->cur_font = OUTP_F_B;
 888 }
 889
 890 void
 891 ascii_text_set_font_by_position (struct outp_driver *this, int pos)
 892 {
 893   struct ascii_driver_ext *x = this->ext;
 894   assert (this->driver_open && this->page_open);
 895   x->cur_font = pos >= 0 && pos < 4 ? pos : 0;
 896 }
 897
 898 void
 899 ascii_text_set_font_by_family (struct outp_driver *this unused, const char *s unused)
 900 {
 901   assert (this->driver_open && this->page_open);
 902 }
 903
 904 const char *
 905 ascii_text_get_font_name (struct outp_driver *this)
 906 {
 907   struct ascii_driver_ext *x = this->ext;
 908
 909   assert (this->driver_open && this->page_open);
 910   switch (x->cur_font)
 911     {
 912     case OUTP_F_R:
 913       return "R";
 914     case OUTP_F_I:
 915       return "I";
 916     case OUTP_F_B:
 917       return "B";
 918     case OUTP_F_BI:
 919       return "BI";
 920     default:
 921       assert (0);
 922     }
 923   abort ();
 924 }
 925
 926 const char *
 927 ascii_text_get_font_family (struct outp_driver *this unused)
 928 {
 929   assert (this->driver_open && this->page_open);
 930   return "";
 931 }
 932
 933 int
 934 ascii_text_set_size (struct outp_driver *this, int size)
 935 {
 936   assert (this->driver_open && this->page_open);
 937   return size == this->vert;
 938 }
 939
 940 int
 941 ascii_text_get_size (struct outp_driver *this, int *em_width)
 942 {
 943   assert (this->driver_open && this->page_open);
 944   if (em_width)
 945     *em_width = this->horiz;
 946   return this->vert;
 947 }
 948
 949 static void text_draw (struct outp_driver *this, struct outp_text *t);
 950
 951 /* Divides the text T->S into lines of width T->H.  Sets T->V to the
 952    number of lines necessary.  Actually draws the text if DRAW is
 953    nonzero.
 954
 955    You probably don't want to look at this code. */
 956 static void
 957 delineate (struct outp_driver *this, struct outp_text *t, int draw)
 958 {
 959   /* Width we're fitting everything into. */
 960   int width = t->h / this->horiz;
 961
 962   /* Maximum `y' position we can write to. */
 963   int max_y;
 964
 965   /* Current position in string, character following end of string. */
 966   const char *s = ls_value (&t->s);
 967   const char *end = ls_end (&t->s);
 968
 969   /* Temporary struct outp_text to pass to low-level function. */
 970   struct outp_text temp;
 971
 972 #if GLOBAL_DEBUGGING && 0
 973   if (!ext->debug)
 974     {
 975       ext->debug = 1;
 976       printf (_("%s: horiz=%d, vert=%d\n"), this->name, this->horiz, this->vert);
 977     }
 978 #endif
 979
 980   if (!width)
 981     {
 982       t->h = t->v = 0;
 983       return;
 984     }
 985
 986   if (draw)
 987     {
 988       temp.options = t->options;
 989       ls_shallow_copy (&temp.s, &t->s);
 990       temp.h = t->h / this->horiz;
 991       temp.x = t->x / this->horiz;
 992     }
 993   else
 994     t->y = 0;
 995   temp.y = t->y / this->vert;
 996
 997   if (t->options & OUTP_T_VERT)
 998     max_y = (t->v / this->vert) + temp.y - 1;
 999   else
1000     max_y = INT_MAX;
1001
1002   while (end - s > width)
1003     {
1004       const char *beg = s;
1005       const char *space;
1006
1007       /* Find first space before &s[width]. */
1008       space = &s[width];
1009       for (;;)
1010         {
1011           if (space > s)
1012             {
1013               if (!isspace ((unsigned char) space[-1]))
1014                 {
1015                   space--;
1016                   continue;
1017                 }
1018               else
1019                 s = space;
1020             }
1021           else
1022             s = space = &s[width];
1023           break;
1024         }
1025
1026       /* Draw text. */
1027       if (draw)
1028         {
1029           ls_init (&temp.s, beg, space - beg);
1030           temp.w = space - beg;
1031           text_draw (this, &temp);
1032         }
1033       if (++temp.y > max_y)
1034         return;
1035
1036       /* Find first nonspace after space. */
1037       while (s < end && isspace ((unsigned char) *s))
1038         s++;
1039     }
1040   if (s < end)
1041     {
1042       if (draw)
1043         {
1044           ls_init (&temp.s, s, end - s);
1045           temp.w = end - s;
1046           text_draw (this, &temp);
1047         }
1048       temp.y++;
1049     }
1050
1051   t->v = (temp.y * this->vert) - t->y;
1052 }
1053
1054 void
1055 ascii_text_metrics (struct outp_driver *this, struct outp_text *t)
1056 {
1057   assert (this->driver_open && this->page_open);
1058   if (!(t->options & OUTP_T_HORZ))
1059     {
1060       t->v = this->vert;
1061       t->h = ls_length (&t->s) * this->horiz;
1062     }
1063   else
1064     delineate (this, t, 0);
1065 }
1066
1067 void
1068 ascii_text_draw (struct outp_driver *this, struct outp_text *t)
1069 {
1070   /* FIXME: orientations not supported. */
1071   assert (this->driver_open && this->page_open);
1072   if (!(t->options & OUTP_T_HORZ))
1073     {
1074       struct outp_text temp;
1075
1076       temp.options = t->options;
1077       temp.s = t->s;
1078       temp.h = temp.v = 0;
1079       temp.x = t->x / this->horiz;
1080       temp.y = t->y / this->vert;
1081       text_draw (this, &temp);
1082       ascii_text_metrics (this, t);
1083
1084       return;
1085     }
1086   delineate (this, t, 1);
1087 }
1088
1089 static void
1090 text_draw (struct outp_driver *this, struct outp_text *t)
1091 {
1092   struct ascii_driver_ext *ext = this->ext;
1093   unsigned attr = ext->cur_font << 8;
1094
1095   int x = t->x;
1096   int y = t->y * ext->w;
1097
1098   char *s = ls_value (&t->s);
1099
1100   /* Expand the line with the assumption that S takes up LEN character
1101      spaces (sometimes it takes up less). */
1102   int min_len;
1103
1104   assert (this->driver_open && this->page_open);
1105   switch (t->options & OUTP_T_JUST_MASK)
1106     {
1107     case OUTP_T_JUST_LEFT:
1108       break;
1109     case OUTP_T_JUST_CENTER:
1110       x -= (t->h - t->w) / 2;   /* fall through */
1111     case OUTP_T_JUST_RIGHT:
1112       x += (t->h - t->w);
1113       break;
1114     default:
1115       assert (0);
1116     }
1117
1118   if (!(t->y < ext->l && x < ext->w))
1119     return;
1120   min_len = min (x + ls_length (&t->s), ext->w);
1121   if (ext->line_len[t->y] < min_len)
1122     expand_line (ext, t->y, min_len);
1123
1124   {
1125     int len = ls_length (&t->s);
1126
1127     if (len + x > ext->w)
1128       len = ext->w - x;
1129     while (len--)
1130       ext->page[y + x++] = *s++ | attr;
1131   }
1132 }
1133 \f
1134 /* ascii_close_page () and support routines. */
1135
1136 #define LINE_BUF_SIZE 1024
1137 static unsigned char *line_buf;
1138 static unsigned char *line_p;
1139
1140 static inline int
1141 commit_line_buf (struct outp_driver *this)
1142 {
1143   struct ascii_driver_ext *x = this->ext;
1144
1145   if ((int) fwrite (line_buf, 1, line_p - line_buf, x->file.file)
1146       < line_p - line_buf)
1147     {
1148       msg (ME, _("Writing `%s': %s"), x->file.filename, strerror (errno));
1149       return 0;
1150     }
1151
1152   line_p = line_buf;
1153   return 1;
1154 }
1155
1156 /* Writes everything from BP to EP exclusive into line_buf, or to
1157    THIS->output if line_buf overflows. */
1158 static inline void
1159 output_string (struct outp_driver *this, const char *bp, const char *ep)
1160 {
1161   if (LINE_BUF_SIZE - (line_p - line_buf) >= ep - bp)
1162     {
1163       memcpy (line_p, bp, ep - bp);
1164       line_p += ep - bp;
1165     }
1166   else
1167     while (bp < ep)
1168       {
1169         if (LINE_BUF_SIZE - (line_p - line_buf) <= 1 && !commit_line_buf (this))
1170           return;
1171         *line_p++ = *bp++;
1172       }
1173 }
1174
1175 /* Writes everything from BP to EP exclusive into line_buf, or to
1176    THIS->output if line_buf overflows.  Returns 1 if additional passes
1177    over the line are required.  FIXME: probably could do a lot of
1178    optimization here. */
1179 static inline int
1180 output_shorts (struct outp_driver *this,
1181                const unsigned short *bp, const unsigned short *ep)
1182 {
1183   struct ascii_driver_ext *ext = this->ext;
1184   size_t remaining = LINE_BUF_SIZE - (line_p - line_buf);
1185   int result = 0;
1186
1187   for (; bp < ep; bp++)
1188     {
1189       if (*bp & 0x800)
1190         {
1191           struct len_string *box = &ext->box[*bp & 0xff];
1192           size_t len = ls_length (box);
1193
1194           if (remaining >= len)
1195             {
1196               memcpy (line_p, ls_value (box), len);
1197               line_p += len;
1198               remaining -= len;
1199             }
1200           else
1201             {
1202               if (!commit_line_buf (this))
1203                 return 0;
1204               output_string (this, ls_value (box), ls_end (box));
1205               remaining = LINE_BUF_SIZE - (line_p - line_buf);
1206             }
1207         }
1208       else if (*bp & 0x0300)
1209         {
1210           struct len_string *on;
1211           char buf[5];
1212           int len;
1213
1214           switch (*bp & 0x0300)
1215             {
1216             case OUTP_F_I << 8:
1217               on = &ext->fonts[FSTY_ON | FSTY_ITALIC];
1218               break;
1219             case OUTP_F_B << 8:
1220               on = &ext->fonts[FSTY_ON | FSTY_BOLD];
1221               break;
1222             case OUTP_F_BI << 8:
1223               on = &ext->fonts[FSTY_ON | FSTY_BOLD_ITALIC];
1224               break;
1225             default:
1226               assert (0);
1227             }
1228           if (!on)
1229             {
1230               if (ext->overstrike_style == OVS_SINGLE)
1231                 switch (*bp & 0x0300)
1232                   {
1233                   case OUTP_F_I << 8:
1234                     buf[0] = '_';
1235                     buf[1] = '\b';
1236                     buf[2] = *bp;
1237                     len = 3;
1238                     break;
1239                   case OUTP_F_B << 8:
1240                     buf[0] = *bp;
1241                     buf[1] = '\b';
1242                     buf[2] = *bp;
1243                     len = 3;
1244                     break;
1245                   case OUTP_F_BI << 8:
1246                     buf[0] = '_';
1247                     buf[1] = '\b';
1248                     buf[2] = *bp;
1249                     buf[3] = '\b';
1250                     buf[4] = *bp;
1251                     len = 5;
1252                     break;
1253                   default:
1254                     assert (0);
1255                   }
1256               else
1257                 {
1258                   buf[0] = *bp;
1259                   result = len = 1;
1260                 }
1261             }
1262           else
1263             {
1264               buf[0] = *bp;
1265               len = 1;
1266             }
1267           output_string (this, buf, &buf[len]);
1268         }
1269       else if (remaining)
1270         {
1271           *line_p++ = *bp;
1272           remaining--;
1273         }
1274       else
1275         {
1276           if (!commit_line_buf (this))
1277             return 0;
1278           remaining = LINE_BUF_SIZE - (line_p - line_buf);
1279           *line_p++ = *bp;
1280         }
1281     }
1282
1283   return result;
1284 }
1285
1286 /* Writes CH into line_buf N times, or to THIS->output if line_buf
1287    overflows. */
1288 static inline void
1289 output_char (struct outp_driver *this, int n, int ch)
1290 {
1291   if (LINE_BUF_SIZE - (line_p - line_buf) >= n)
1292     {
1293       memset (line_p, ch, n);
1294       line_p += n;
1295     }
1296   else
1297     while (n--)
1298       {
1299         if (LINE_BUF_SIZE - (line_p - line_buf) <= 1 && !commit_line_buf (this))
1300           return;
1301         *line_p++ = ch;
1302       }
1303 }
1304
1305 /* Advance the carriage from column 0 to the left margin. */
1306 static void
1307 advance_to_left_margin (struct outp_driver *this)
1308 {
1309   struct ascii_driver_ext *ext = this->ext;
1310   int margin;
1311
1312   margin = ext->left_margin;
1313   if (margin == 0)
1314     return;
1315   if (ext->tab_width && margin >= ext->tab_width)
1316     {
1317       output_char (this, margin / ext->tab_width, '\t');
1318       margin %= ext->tab_width;
1319     }
1320   if (margin)
1321     output_char (this, margin, ' ');
1322 }
1323
1324 /* Move the output file carriage N_CHARS left, to the left margin. */
1325 static void
1326 return_carriage (struct outp_driver *this, int n_chars)
1327 {
1328   struct ascii_driver_ext *ext = this->ext;
1329
1330   switch (ext->carriage_return_style)
1331     {
1332     case CRS_BS:
1333       output_char (this, n_chars, '\b');
1334       break;
1335     case CRS_CR:
1336       output_char (this, 1, '\r');
1337       advance_to_left_margin (this);
1338       break;
1339     default:
1340       assert (0);
1341     }
1342 }
1343
1344 /* Writes COUNT lines from the line buffer in THIS, starting at line
1345    number FIRST. */
1346 static void
1347 output_lines (struct outp_driver *this, int first, int count)
1348 {
1349   struct ascii_driver_ext *ext = this->ext;
1350
1351   unsigned short *p = &ext->page[ext->w * first];
1352   int *len = &ext->line_len[first];
1353   struct len_string *newline = &ext->ops[OPS_NEWLINE];
1354
1355   int n_chars;
1356   int n_passes;
1357
1358   if (NULL == ext->file.file)
1359     return;
1360
1361   while (count--)               /* Iterate over all the lines to be output. */
1362     {
1363       unsigned short *end_p;
1364       unsigned short *bp, *ep;
1365       unsigned short attr = 0;
1366
1367       end_p = p + *len++;
1368       assert (end_p >= p);
1369
1370       /* Output every character in the line in the appropriate
1371          manner. */
1372       n_passes = 1;
1373       bp = ep = p;
1374       n_chars = 0;
1375       advance_to_left_margin (this);
1376       for (;;)
1377         {
1378           while (ep < end_p && attr == (*ep & 0x0300))
1379             ep++;
1380           if (output_shorts (this, bp, ep))
1381             n_passes = 2;
1382           n_chars += ep - bp;
1383           bp = ep;
1384
1385           if (bp >= end_p)
1386             break;
1387
1388           /* Turn off old font. */
1389           if (attr != (OUTP_F_R << 8))
1390             {
1391               struct len_string *off;
1392
1393               switch (attr)
1394                 {
1395                 case OUTP_F_I << 8:
1396                   off = &ext->fonts[FSTY_OFF | FSTY_ITALIC];
1397                   break;
1398                 case OUTP_F_B << 8:
1399                   off = &ext->fonts[FSTY_OFF | FSTY_BOLD];
1400                   break;
1401                 case OUTP_F_BI << 8:
1402                   off = &ext->fonts[FSTY_OFF | FSTY_BOLD_ITALIC];
1403                   break;
1404                 default:
1405                   assert (0);
1406                 }
1407               if (off)
1408                 output_string (this, ls_value (off), ls_end (off));
1409             }
1410
1411           /* Turn on new font. */
1412           attr = (*bp & 0x0300);
1413           if (attr != (OUTP_F_R << 8))
1414             {
1415               struct len_string *on;
1416
1417               switch (attr)
1418                 {
1419                 case OUTP_F_I << 8:
1420                   on = &ext->fonts[FSTY_ON | FSTY_ITALIC];
1421                   break;
1422                 case OUTP_F_B << 8:
1423                   on = &ext->fonts[FSTY_ON | FSTY_BOLD];
1424                   break;
1425                 case OUTP_F_BI << 8:
1426                   on = &ext->fonts[FSTY_ON | FSTY_BOLD_ITALIC];
1427                   break;
1428                 default:
1429                   assert (0);
1430                 }
1431               if (on)
1432                 output_string (this, ls_value (on), ls_end (on));
1433             }
1434
1435           ep = bp + 1;
1436         }
1437       if (n_passes > 1)
1438         {
1439           unsigned char ch;
1440
1441           return_carriage (this, n_chars);
1442           n_chars = 0;
1443           bp = ep = p;
1444           for (;;)
1445             {
1446               while (ep < end_p && (*ep & 0x0300) == (OUTP_F_R << 8))
1447                 ep++;
1448               if (ep >= end_p)
1449                 break;
1450               output_char (this, ep - bp, ' ');
1451
1452               switch (*ep & 0x0300)
1453                 {
1454                 case OUTP_F_I << 8:
1455                   ch = '_';
1456                   break;
1457                 case OUTP_F_B << 8:
1458                   ch = *ep;
1459                   break;
1460                 case OUTP_F_BI << 8:
1461                   ch = *ep;
1462                   n_passes = 3;
1463                   break;
1464                 }
1465               output_char (this, 1, ch);
1466               n_chars += ep - bp + 1;
1467               bp = ep + 1;
1468               ep = bp;
1469             }
1470         }
1471       if (n_passes > 2)
1472         {
1473           return_carriage (this, n_chars);
1474           bp = ep = p;
1475           for (;;)
1476             {
1477               while (ep < end_p && (*ep & 0x0300) != (OUTP_F_BI << 8))
1478                 ep++;
1479               if (ep >= end_p)
1480                 break;
1481               output_char (this, ep - bp, ' ');
1482               output_char (this, 1, '_');
1483               bp = ep + 1;
1484               ep = bp;
1485             }
1486         }
1487       p += ext->w;
1488
1489       output_string (this, ls_value (newline), ls_end (newline));
1490     }
1491 }
1492
1493 int
1494 ascii_close_page (struct outp_driver *this)
1495 {
1496   static unsigned char *s;
1497   static int s_len;
1498
1499   struct ascii_driver_ext *x = this->ext;
1500   int nl_len, ff_len, total_len;
1501   unsigned char *cp;
1502   int i;
1503
1504   assert (this->driver_open && this->page_open);
1505
1506   if (!line_buf)
1507     line_buf = xmalloc (LINE_BUF_SIZE);
1508   line_p = line_buf;
1509
1510   nl_len = ls_length (&x->ops[OPS_NEWLINE]);
1511   if (x->top_margin)
1512     {
1513       total_len = x->top_margin * nl_len;
1514       if (s_len < total_len)
1515         {
1516           s_len = total_len;
1517           s = xrealloc (s, s_len);
1518         }
1519       for (cp = s, i = 0; i < x->top_margin; i++)
1520         {
1521           memcpy (cp, ls_value (&x->ops[OPS_NEWLINE]), nl_len);
1522           cp += nl_len;
1523         }
1524       output_string (this, s, &s[total_len]);
1525     }
1526   if (x->headers)
1527     {
1528       int len;
1529
1530       total_len = nl_len + x->w;
1531       if (s_len < total_len + 1)
1532         {
1533           s_len = total_len + 1;
1534           s = xrealloc (s, s_len);
1535         }
1536
1537       memset (s, ' ', x->w);
1538
1539       {
1540         char temp[40];
1541
1542         snprintf (temp, 80, _("%s - Page %d"), curdate, x->page_number);
1543         memcpy (&s[x->w - strlen (temp)], temp, strlen (temp));
1544       }
1545
1546       if (outp_title && outp_subtitle)
1547         {
1548           len = min ((int) strlen (outp_title), x->w);
1549           memcpy (s, outp_title, len);
1550         }
1551       memcpy (&s[x->w], ls_value (&x->ops[OPS_NEWLINE]), nl_len);
1552       output_string (this, s, &s[total_len]);
1553
1554       memset (s, ' ', x->w);
1555       len = strlen (version) + 3 + strlen (host_system);
1556       if (len < x->w)
1557         sprintf (&s[x->w - len], "%s - %s" , version, host_system);
1558       if (outp_subtitle || outp_title)
1559         {
1560           char *string = outp_subtitle ? outp_subtitle : outp_title;
1561           len = min ((int) strlen (string), x->w);
1562           memcpy (s, string, len);
1563         }
1564       memcpy (&s[x->w], ls_value (&x->ops[OPS_NEWLINE]), nl_len);
1565       output_string (this, s, &s[total_len]);
1566       output_string (this, &s[x->w], &s[total_len]);
1567     }
1568   if (line_p != line_buf && !commit_line_buf (this))
1569     return 0;
1570
1571   output_lines (this, x->n_output, x->l - x->n_output);
1572
1573   ff_len = ls_length (&x->ops[OPS_FORMFEED]);
1574   total_len = x->bottom_margin * nl_len + ff_len;
1575   if (s_len < total_len)
1576     s = xrealloc (s, total_len);
1577   for (cp = s, i = 0; i < x->bottom_margin; i++)
1578     {
1579       memcpy (cp, ls_value (&x->ops[OPS_NEWLINE]), nl_len);
1580       cp += nl_len;
1581     }
1582   memcpy (cp, ls_value (&x->ops[OPS_FORMFEED]), ff_len);
1583   output_string (this, s, &s[total_len]);
1584   if (line_p != line_buf && !commit_line_buf (this))
1585     return 0;
1586
1587   x->n_output = 0;
1588
1589   this->page_open = 0;
1590   return 1;
1591 }
1592
1593 struct outp_class ascii_class =
1594 {
1595   "ascii",
1596   0,
1597   0,
1598
1599   ascii_open_global,
1600   ascii_close_global,
1601   ascii_font_sizes,
1602
1603   ascii_preopen_driver,
1604   ascii_option,
1605   ascii_postopen_driver,
1606   ascii_close_driver,
1607
1608   ascii_open_page,
1609   ascii_close_page,
1610
1611   NULL,
1612
1613   ascii_line_horz,
1614   ascii_line_vert,
1615   ascii_line_intersection,
1616
1617   ascii_box,
1618   ascii_polyline_begin,
1619   ascii_polyline_point,
1620   ascii_polyline_end,
1621
1622   ascii_text_set_font_by_name,
1623   ascii_text_set_font_by_position,
1624   ascii_text_set_font_by_family,
1625   ascii_text_get_font_name,
1626   ascii_text_get_font_family,
1627   ascii_text_set_size,
1628   ascii_text_get_size,
1629   ascii_text_metrics,
1630   ascii_text_draw,
1631 };