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