pintos-os.org Git - pspp/blob - src/output/ascii.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 1997-9, 2000, 2007, 2009, 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  16
  17 #include <config.h>
  18
  19 #include <ctype.h>
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24 #include <signal.h>
  25 #include <unilbrk.h>
  26 #include <unistd.h>
  27 #include <unistr.h>
  28 #include <uniwidth.h>
  29
  30 #include "data/file-name.h"
  31 #include "data/file-handle-def.h"
  32 #include "data/settings.h"
  33 #include "libpspp/assertion.h"
  34 #include "libpspp/cast.h"
  35 #include "libpspp/compiler.h"
  36 #include "libpspp/message.h"
  37 #include "libpspp/start-date.h"
  38 #include "libpspp/string-map.h"
  39 #include "libpspp/u8-line.h"
  40 #include "libpspp/version.h"
  41 #include "output/ascii.h"
  42 #include "output/cairo.h"
  43 #include "output/chart-item-provider.h"
  44 #include "output/driver-provider.h"
  45 #include "output/message-item.h"
  46 #include "output/options.h"
  47 #include "output/render.h"
  48 #include "output/table-item.h"
  49 #include "output/text-item.h"
  50
  51 #include "gl/minmax.h"
  52 #include "gl/xalloc.h"
  53 #include "gl/xsize.h"
  54
  55 #include "gettext.h"
  56 #define _(msgid) gettext (msgid)
  57
  58 /* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
  59 #define H TABLE_HORZ
  60 #define V TABLE_VERT
  61
  62 enum
  63   {
  64     ASCII_LINE_NONE,
  65     ASCII_LINE_SINGLE,
  66     ASCII_LINE_DOUBLE,
  67     ASCII_N_LINES
  68   };
  69
  70 #define N_BOX (ASCII_N_LINES * ASCII_N_LINES \
  71                * ASCII_N_LINES * ASCII_N_LINES)
  72
  73 static const ucs4_t ascii_box_chars[N_BOX] =
  74   {
  75     ' ', '|', '#',
  76     '-', '+', '#',
  77     '=', '#', '#',
  78     '|', '|', '#',
  79     '+', '+', '#',
  80     '#', '#', '#',
  81     '#', '#', '#',
  82     '#', '#', '#',
  83     '#', '#', '#',
  84     '-', '+', '#',
  85     '-', '+', '#',
  86     '#', '#', '#',
  87     '+', '+', '#',
  88     '+', '+', '#',
  89     '#', '#', '#',
  90     '#', '#', '#',
  91     '#', '#', '#',
  92     '#', '#', '#',
  93     '=', '#', '#',
  94     '#', '#', '#',
  95     '=', '#', '#',
  96     '#', '#', '#',
  97     '#', '#', '#',
  98     '#', '#', '#',
  99     '#', '#', '#',
 100     '#', '#', '#',
 101     '#', '#', '#',
 102   };
 103
 104 static const ucs4_t unicode_box_chars[N_BOX] =
 105   {
 106     0x0020, 0x2575, 0x2551,
 107     0x2574, 0x256f, 0x255c,
 108     0x2550, 0x255b, 0x255d,
 109     0x2577, 0x2502, 0x2551,
 110     0x256e, 0x2524, 0x2562,
 111     0x2555, 0x2561, 0x2563,
 112     0x2551, 0x2551, 0x2551,
 113     0x2556, 0x2562, 0x2562,
 114     0x2557, 0x2563, 0x2563,
 115     0x2576, 0x2570, 0x2559,
 116     0x2500, 0x2534, 0x2568,
 117     0x2550, 0x2567, 0x2569,
 118     0x256d, 0x251c, 0x255f,
 119     0x252c, 0x253c, 0x256a,
 120     0x2564, 0x256a, 0x256c,
 121     0x2553, 0x255f, 0x255f,
 122     0x2565, 0x256b, 0x256b,
 123     0x2566, 0x256c, 0x256c,
 124     0x2550, 0x2558, 0x255a,
 125     0x2550, 0x2567, 0x2569,
 126     0x2550, 0x2567, 0x2569,
 127     0x2552, 0x255e, 0x2560,
 128     0x2564, 0x256a, 0x256c,
 129     0x2564, 0x256a, 0x256c,
 130     0x2554, 0x2560, 0x2560,
 131     0x2560, 0x256c, 0x256c,
 132     0x2566, 0x256c, 0x256c,
 133   };
 134
 135 static int
 136 ascii_line_from_render_line (int render_line)
 137 {
 138   switch (render_line)
 139     {
 140     case RENDER_LINE_NONE:
 141       return ASCII_LINE_NONE;
 142
 143     case RENDER_LINE_SINGLE:
 144     case RENDER_LINE_DASHED:
 145     case RENDER_LINE_THICK:
 146     case RENDER_LINE_THIN:
 147       return ASCII_LINE_SINGLE;
 148
 149     case RENDER_LINE_DOUBLE:
 150       return ASCII_LINE_DOUBLE;
 151
 152     default:
 153       return ASCII_LINE_NONE;
 154     }
 155
 156 }
 157
 158 static int
 159 make_box_index (int left_, int right_, int top_, int bottom_)
 160 {
 161   bool rtl = render_direction_rtl ();
 162   int left = ascii_line_from_render_line (rtl ? right_ : left_);
 163   int right = ascii_line_from_render_line (rtl ? left_ : right_);
 164   int top = ascii_line_from_render_line (top_);
 165   int bottom = ascii_line_from_render_line (bottom_);
 166
 167   int idx = right;
 168   idx = idx * ASCII_N_LINES + bottom;
 169   idx = idx * ASCII_N_LINES + left;
 170   idx = idx * ASCII_N_LINES + top;
 171   return idx;
 172 }
 173
 174 /* ASCII output driver. */
 175 struct ascii_driver
 176   {
 177     struct output_driver driver;
 178
 179     /* User parameters. */
 180     bool append;                /* Append if output file already exists? */
 181     bool emphasis;              /* Enable bold and underline in output? */
 182     char *chart_file_name;      /* Name of files used for charts. */
 183
 184 #ifdef HAVE_CAIRO
 185     /* Colours for charts */
 186     struct cell_color fg;
 187     struct cell_color bg;
 188 #endif
 189
 190     int width;                  /* Page width. */
 191     bool auto_width;            /* Use viewwidth as page width? */
 192
 193     int min_break[TABLE_N_AXES]; /* Min cell size to break across pages. */
 194
 195     const ucs4_t *box;          /* Line & box drawing characters. */
 196
 197     /* Internal state. */
 198     struct file_handle *handle;
 199     FILE *file;                 /* Output file. */
 200     bool error;                 /* Output error? */
 201     struct u8_line *lines;      /* Page content. */
 202     int allocated_lines;        /* Number of lines allocated. */
 203     int chart_cnt;              /* Number of charts so far. */
 204     struct render_params params;
 205   };
 206
 207 static const struct output_driver_class ascii_driver_class;
 208
 209 static void ascii_submit (struct output_driver *, const struct output_item *);
 210
 211 static bool update_page_size (struct ascii_driver *, bool issue_error);
 212 static int parse_page_size (struct driver_option *);
 213
 214 static bool ascii_open_page (struct ascii_driver *);
 215
 216 static void ascii_draw_line (void *, int bb[TABLE_N_AXES][2],
 217                              enum render_line_style styles[TABLE_N_AXES][2],
 218                              struct cell_color colors[TABLE_N_AXES][2]);
 219 static void ascii_measure_cell_width (void *, const struct table_cell *,
 220                                       int *min, int *max);
 221 static int ascii_measure_cell_height (void *, const struct table_cell *,
 222                                       int width);
 223 static void ascii_draw_cell (void *, const struct table_cell *, int color_idx,
 224                              int bb[TABLE_N_AXES][2],
 225                              int spill[TABLE_N_AXES][2],
 226                              int clip[TABLE_N_AXES][2]);
 227
 228 static struct ascii_driver *
 229 ascii_driver_cast (struct output_driver *driver)
 230 {
 231   assert (driver->class == &ascii_driver_class);
 232   return UP_CAST (driver, struct ascii_driver, driver);
 233 }
 234
 235 static struct driver_option *
 236 opt (struct output_driver *d, struct string_map *options, const char *key,
 237      const char *default_value)
 238 {
 239   return driver_option_get (d, options, key, default_value);
 240 }
 241
 242 /* Return true iff the terminal appears to be an xterm with
 243    UTF-8 capabilities */
 244 static bool
 245 term_is_utf8_xterm (void)
 246 {
 247   const char *term = getenv ("TERM");
 248   const char *xterm_locale = getenv ("XTERM_LOCAL");
 249   return (term && xterm_locale
 250           && !strcmp (term, "xterm")
 251           && (strcasestr (xterm_locale, "utf8")
 252               || strcasestr (xterm_locale, "utf-8")));
 253 }
 254
 255 static struct output_driver *
 256 ascii_create (struct  file_handle *fh, enum settings_output_devices device_type,
 257               struct string_map *o)
 258 {
 259   enum { BOX_ASCII, BOX_UNICODE } box;
 260   int min_break[TABLE_N_AXES];
 261   struct output_driver *d;
 262   struct ascii_driver *a;
 263
 264   a = xzalloc (sizeof *a);
 265   d = &a->driver;
 266   output_driver_init (&a->driver, &ascii_driver_class, fh_get_file_name (fh), device_type);
 267   a->append = parse_boolean (opt (d, o, "append", "false"));
 268   a->emphasis = parse_boolean (opt (d, o, "emphasis", "false"));
 269
 270   a->chart_file_name = parse_chart_file_name (opt (d, o, "charts", fh_get_file_name (fh)));
 271   a->handle = fh;
 272
 273   min_break[H] = parse_int (opt (d, o, "min-hbreak", "-1"), -1, INT_MAX);
 274
 275   a->width = parse_page_size (opt (d, o, "width", "79"));
 276   a->auto_width = a->width < 0;
 277   a->min_break[H] = min_break[H] >= 0 ? min_break[H] : a->width / 2;
 278 #ifdef HAVE_CAIRO
 279   parse_color (d, o, "background-color", "#FFFFFFFFFFFF", &a->bg);
 280   parse_color (d, o, "foreground-color", "#000000000000", &a->fg);
 281 #endif
 282
 283   const char *default_box = (!strcmp (fh_get_file_name (fh), "-")
 284                              && isatty (STDOUT_FILENO)
 285                              && (!strcmp (locale_charset (), "UTF-8")
 286                                  || term_is_utf8_xterm ())
 287                              ? "unicode" : "ascii");
 288   box = parse_enum (opt (d, o, "box", default_box),
 289                     "ascii", BOX_ASCII,
 290                     "unicode", BOX_UNICODE,
 291                     NULL_SENTINEL);
 292   a->box = box == BOX_ASCII ? ascii_box_chars : unicode_box_chars;
 293
 294   a->file = NULL;
 295   a->error = false;
 296   a->lines = NULL;
 297   a->allocated_lines = 0;
 298   a->chart_cnt = 1;
 299
 300   a->params.draw_line = ascii_draw_line;
 301   a->params.measure_cell_width = ascii_measure_cell_width;
 302   a->params.measure_cell_height = ascii_measure_cell_height;
 303   a->params.adjust_break = NULL;
 304   a->params.draw_cell = ascii_draw_cell;
 305   a->params.aux = a;
 306   a->params.size[H] = a->width;
 307   a->params.size[V] = INT_MAX;
 308   a->params.font_size[H] = 1;
 309   a->params.font_size[V] = 1;
 310   for (int i = 0; i < RENDER_N_LINES; i++)
 311     {
 312       int width = i == RENDER_LINE_NONE ? 0 : 1;
 313       a->params.line_widths[H][i] = width;
 314       a->params.line_widths[V][i] = width;
 315     }
 316   for (int i = 0; i < TABLE_N_AXES; i++)
 317     a->params.min_break[i] = a->min_break[i];
 318   a->params.supports_margins = false;
 319   a->params.rtl = render_direction_rtl ();
 320
 321   if (!update_page_size (a, true))
 322     goto error;
 323
 324   return d;
 325
 326 error:
 327   output_driver_destroy (d);
 328   return NULL;
 329 }
 330
 331 static int
 332 parse_page_size (struct driver_option *option)
 333 {
 334   int dim = atol (option->default_value);
 335
 336   if (option->value != NULL)
 337     {
 338       if (!strcmp (option->value, "auto"))
 339         dim = -1;
 340       else
 341         {
 342           int value;
 343           char *tail;
 344
 345           errno = 0;
 346           value = strtol (option->value, &tail, 0);
 347           if (dim >= 1 && errno != ERANGE && *tail == '\0')
 348             dim = value;
 349           else
 350             msg (MW, _("%s: %s must be positive integer or `auto'"),
 351                    option->driver_name, option->name);
 352         }
 353     }
 354
 355   driver_option_destroy (option);
 356
 357   return dim;
 358 }
 359
 360 /* Re-calculates the page width based on settings, margins, and, if "auto" is
 361    set, the size of the user's terminal window or GUI output window. */
 362 static bool
 363 update_page_size (struct ascii_driver *a, bool issue_error)
 364 {
 365   enum { MIN_WIDTH = 6, MIN_LENGTH = 6 };
 366
 367   if (a->auto_width)
 368     {
 369       a->params.size[H] = a->width = settings_get_viewwidth ();
 370       a->params.min_break[H] = a->min_break[H] = a->width / 2;
 371     }
 372
 373   if (a->width < MIN_WIDTH)
 374     {
 375       if (issue_error)
 376         msg (ME,
 377                _("ascii: page must be at least %d characters wide, but "
 378                  "as configured is only %d characters"),
 379                MIN_WIDTH,
 380                a->width);
 381       if (a->width < MIN_WIDTH)
 382         a->params.size[H] = a->width = MIN_WIDTH;
 383       return false;
 384     }
 385
 386   return true;
 387 }
 388
 389 static void
 390 ascii_destroy (struct output_driver *driver)
 391 {
 392   struct ascii_driver *a = ascii_driver_cast (driver);
 393   int i;
 394
 395   if (a->file != NULL)
 396     fn_close (a->handle, a->file);
 397   fh_unref (a->handle);
 398   free (a->chart_file_name);
 399   for (i = 0; i < a->allocated_lines; i++)
 400     u8_line_destroy (&a->lines[i]);
 401   free (a->lines);
 402   free (a);
 403 }
 404
 405 static void
 406 ascii_flush (struct output_driver *driver)
 407 {
 408   struct ascii_driver *a = ascii_driver_cast (driver);
 409   if (a->file)
 410     fflush (a->file);
 411 }
 412
 413 static void
 414 ascii_output_lines (struct ascii_driver *a, size_t n_lines)
 415 {
 416   for (size_t y = 0; y < n_lines; y++)
 417     {
 418       struct u8_line *line = &a->lines[y];
 419
 420       while (ds_chomp_byte (&line->s, ' '))
 421         continue;
 422       fwrite (ds_data (&line->s), 1, ds_length (&line->s), a->file);
 423       putc ('\n', a->file);
 424
 425       u8_line_clear (&a->lines[y]);
 426     }
 427 }
 428
 429 static void
 430 ascii_output_table_item (struct ascii_driver *a,
 431                          const struct table_item *table_item)
 432 {
 433   struct render_pager *p;
 434
 435   update_page_size (a, false);
 436
 437   if (a->file)
 438     putc ('\n', a->file);
 439   else if (!ascii_open_page (a))
 440     return;
 441
 442   p = render_pager_create (&a->params, table_item);
 443   for (int i = 0; render_pager_has_next (p); i++)
 444     {
 445       if (i)
 446         putc ('\n', a->file);
 447       ascii_output_lines (a, render_pager_draw_next (p, INT_MAX));
 448     }
 449   render_pager_destroy (p);
 450 }
 451
 452 static void
 453 ascii_output_table_item_unref (struct ascii_driver *a,
 454                                struct table_item *table_item)
 455 {
 456   ascii_output_table_item (a, table_item);
 457   table_item_unref (table_item);
 458 }
 459
 460 static void
 461 ascii_output_text (struct ascii_driver *a, const char *text)
 462 {
 463   ascii_output_table_item_unref (
 464     a, table_item_create (table_from_string (text), NULL, NULL));
 465 }
 466
 467 static void
 468 ascii_submit (struct output_driver *driver,
 469               const struct output_item *output_item)
 470 {
 471   struct ascii_driver *a = ascii_driver_cast (driver);
 472
 473   if (a->error)
 474     return;
 475
 476   if (is_table_item (output_item))
 477     ascii_output_table_item (a, to_table_item (output_item));
 478 #ifdef HAVE_CAIRO
 479   else if (is_chart_item (output_item) && a->chart_file_name != NULL)
 480     {
 481       struct chart_item *chart_item = to_chart_item (output_item);
 482       char *file_name;
 483
 484       file_name = xr_draw_png_chart (chart_item, a->chart_file_name,
 485                                      a->chart_cnt++,
 486                                      &a->fg,
 487                                      &a->bg);
 488       if (file_name != NULL)
 489         {
 490           struct text_item *text_item;
 491
 492           text_item = text_item_create_format (
 493             TEXT_ITEM_LOG, _("See %s for a chart."), file_name);
 494
 495           ascii_submit (driver, &text_item->output_item);
 496           text_item_unref (text_item);
 497           free (file_name);
 498         }
 499     }
 500 #endif  /* HAVE_CAIRO */
 501   else if (is_text_item (output_item))
 502     {
 503       const struct text_item *text_item = to_text_item (output_item);
 504       enum text_item_type type = text_item_get_type (text_item);
 505
 506       if (type != TEXT_ITEM_PAGE_TITLE && type != TEXT_ITEM_EJECT_PAGE)
 507         ascii_output_table_item_unref (
 508           a, text_item_to_table_item (text_item_ref (text_item)));
 509     }
 510   else if (is_message_item (output_item))
 511     {
 512       const struct message_item *message_item = to_message_item (output_item);
 513       char *s = msg_to_string (message_item_get_msg (message_item));
 514       ascii_output_text (a, s);
 515       free (s);
 516     }
 517 }
 518
 519 const struct output_driver_factory txt_driver_factory =
 520   { "txt", "-", ascii_create };
 521 const struct output_driver_factory list_driver_factory =
 522   { "list", "-", ascii_create };
 523
 524 static const struct output_driver_class ascii_driver_class =
 525   {
 526     "text",
 527     ascii_destroy,
 528     ascii_submit,
 529     ascii_flush,
 530   };
 531 \f
 532 static char *ascii_reserve (struct ascii_driver *, int y, int x0, int x1,
 533                             int n);
 534 static void ascii_layout_cell (struct ascii_driver *,
 535                                const struct table_cell *,
 536                                int bb[TABLE_N_AXES][2],
 537                                int clip[TABLE_N_AXES][2],
 538                                int *width, int *height);
 539
 540 static void
 541 ascii_draw_line (void *a_, int bb[TABLE_N_AXES][2],
 542                  enum render_line_style styles[TABLE_N_AXES][2],
 543                  struct cell_color colors[TABLE_N_AXES][2] UNUSED)
 544 {
 545   struct ascii_driver *a = a_;
 546   char mbchar[6];
 547   int x0, y0, x1, y1;
 548   ucs4_t uc;
 549   int mblen;
 550   int x, y;
 551
 552   /* Clip to the page. */
 553   x0 = MAX (bb[H][0], 0);
 554   y0 = MAX (bb[V][0], 0);
 555   x1 = MIN (bb[H][1], a->width);
 556   y1 = bb[V][1];
 557   if (x1 <= 0 || y1 <= 0 || x0 >= a->width)
 558     return;
 559
 560   /* Draw. */
 561   uc = a->box[make_box_index (styles[V][0], styles[V][1],
 562                               styles[H][0], styles[H][1])];
 563   mblen = u8_uctomb (CHAR_CAST (uint8_t *, mbchar), uc, 6);
 564   for (y = y0; y < y1; y++)
 565     {
 566       char *p = ascii_reserve (a, y, x0, x1, mblen * (x1 - x0));
 567       for (x = x0; x < x1; x++)
 568         {
 569           memcpy (p, mbchar, mblen);
 570           p += mblen;
 571         }
 572     }
 573 }
 574
 575 static void
 576 ascii_measure_cell_width (void *a_, const struct table_cell *cell,
 577                           int *min_width, int *max_width)
 578 {
 579   struct ascii_driver *a = a_;
 580   int bb[TABLE_N_AXES][2];
 581   int clip[TABLE_N_AXES][2];
 582   int h;
 583
 584   bb[H][0] = 0;
 585   bb[H][1] = INT_MAX;
 586   bb[V][0] = 0;
 587   bb[V][1] = INT_MAX;
 588   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
 589   ascii_layout_cell (a, cell, bb, clip, max_width, &h);
 590
 591   if (cell->n_footnotes || strchr (cell->text, ' '))
 592     {
 593       bb[H][1] = 1;
 594       ascii_layout_cell (a, cell, bb, clip, min_width, &h);
 595     }
 596   else
 597     *min_width = *max_width;
 598 }
 599
 600 static int
 601 ascii_measure_cell_height (void *a_, const struct table_cell *cell, int width)
 602 {
 603   struct ascii_driver *a = a_;
 604   int bb[TABLE_N_AXES][2];
 605   int clip[TABLE_N_AXES][2];
 606   int w, h;
 607
 608   bb[H][0] = 0;
 609   bb[H][1] = width;
 610   bb[V][0] = 0;
 611   bb[V][1] = INT_MAX;
 612   clip[H][0] = clip[H][1] = clip[V][0] = clip[V][1] = 0;
 613   ascii_layout_cell (a, cell, bb, clip, &w, &h);
 614   return h;
 615 }
 616
 617 static void
 618 ascii_draw_cell (void *a_, const struct table_cell *cell, int color_idx UNUSED,
 619                  int bb[TABLE_N_AXES][2],
 620                  int spill[TABLE_N_AXES][2] UNUSED,
 621                  int clip[TABLE_N_AXES][2])
 622 {
 623   struct ascii_driver *a = a_;
 624   int w, h;
 625
 626   ascii_layout_cell (a, cell, bb, clip, &w, &h);
 627 }
 628
 629 static char *
 630 ascii_reserve (struct ascii_driver *a, int y, int x0, int x1, int n)
 631 {
 632   if (y >= a->allocated_lines)
 633     {
 634       size_t new_alloc = MAX (25, a->allocated_lines);
 635       while (new_alloc <= y)
 636         new_alloc = xtimes (new_alloc, 2);
 637       a->lines = xnrealloc (a->lines, new_alloc, sizeof *a->lines);
 638       for (size_t i = a->allocated_lines; i < new_alloc; i++)
 639         u8_line_init (&a->lines[i]);
 640       a->allocated_lines = new_alloc;
 641     }
 642   return u8_line_reserve (&a->lines[y], x0, x1, n);
 643 }
 644
 645 static void
 646 text_draw (struct ascii_driver *a, enum table_halign halign, int options,
 647            bool bold, bool underline,
 648            int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
 649            int y, const uint8_t *string, int n, size_t width)
 650 {
 651   int x0 = MAX (0, clip[H][0]);
 652   int y0 = MAX (0, clip[V][0]);
 653   int x1 = MIN (a->width, clip[H][1]);
 654   int y1 = clip[V][1];
 655   int x;
 656
 657   if (y < y0 || y >= y1)
 658     return;
 659
 660   switch (table_halign_interpret (halign, options & TAB_NUMERIC))
 661     {
 662     case TABLE_HALIGN_LEFT:
 663       x = bb[H][0];
 664       break;
 665     case TABLE_HALIGN_CENTER:
 666       x = (bb[H][0] + bb[H][1] - width + 1) / 2;
 667       break;
 668     case TABLE_HALIGN_RIGHT:
 669     case TABLE_HALIGN_DECIMAL:
 670       x = bb[H][1] - width;
 671       break;
 672     default:
 673       NOT_REACHED ();
 674     }
 675   if (x >= x1)
 676     return;
 677
 678   while (x < x0)
 679     {
 680       ucs4_t uc;
 681       int mblen;
 682       int w;
 683
 684       if (n == 0)
 685         return;
 686       mblen = u8_mbtouc (&uc, string, n);
 687
 688       string += mblen;
 689       n -= mblen;
 690
 691       w = uc_width (uc, "UTF-8");
 692       if (w > 0)
 693         {
 694           x += w;
 695           width -= w;
 696         }
 697     }
 698   if (n == 0)
 699     return;
 700
 701   if (x + width > x1)
 702     {
 703       int ofs;
 704
 705       ofs = width = 0;
 706       for (ofs = 0; ofs < n; )
 707         {
 708           ucs4_t uc;
 709           int mblen;
 710           int w;
 711
 712           mblen = u8_mbtouc (&uc, string + ofs, n - ofs);
 713
 714           w = uc_width (uc, "UTF-8");
 715           if (w > 0)
 716             {
 717               if (width + w > x1 - x)
 718                 break;
 719               width += w;
 720             }
 721           ofs += mblen;
 722         }
 723       n = ofs;
 724       if (n == 0)
 725         return;
 726     }
 727
 728   if (!a->emphasis || (!bold && !underline))
 729     memcpy (ascii_reserve (a, y, x, x + width, n), string, n);
 730   else
 731     {
 732       size_t n_out;
 733       size_t ofs;
 734       char *out;
 735       int mblen;
 736
 737       /* First figure out how many bytes need to be inserted. */
 738       n_out = n;
 739       for (ofs = 0; ofs < n; ofs += mblen)
 740         {
 741           ucs4_t uc;
 742           int w;
 743
 744           mblen = u8_mbtouc (&uc, string + ofs, n - ofs);
 745           w = uc_width (uc, "UTF-8");
 746
 747           if (w > 0)
 748             {
 749               if (bold)
 750                 n_out += 1 + mblen;
 751               if (underline)
 752                 n_out += 2;
 753             }
 754         }
 755
 756       /* Then insert them. */
 757       out = ascii_reserve (a, y, x, x + width, n_out);
 758       for (ofs = 0; ofs < n; ofs += mblen)
 759         {
 760           ucs4_t uc;
 761           int w;
 762
 763           mblen = u8_mbtouc (&uc, string + ofs, n - ofs);
 764           w = uc_width (uc, "UTF-8");
 765
 766           if (w > 0)
 767             {
 768               if (bold)
 769                 {
 770                   out = mempcpy (out, string + ofs, mblen);
 771                   *out++ = '\b';
 772                 }
 773               if (underline)
 774                 {
 775                   *out++ = '_';
 776                   *out++ = '\b';
 777                 }
 778             }
 779           out = mempcpy (out, string + ofs, mblen);
 780         }
 781     }
 782 }
 783
 784 static char *
 785 add_footnote_markers (const char *text, const struct table_cell *cell)
 786 {
 787   struct string s = DS_EMPTY_INITIALIZER;
 788   ds_put_cstr (&s, text);
 789   for (size_t i = 0; i < cell->n_footnotes; i++)
 790     ds_put_format (&s, "[%s]", cell->footnotes[i]->marker);
 791   return ds_steal_cstr (&s);
 792 }
 793
 794 static void
 795 ascii_layout_cell (struct ascii_driver *a, const struct table_cell *cell,
 796                    int bb[TABLE_N_AXES][2], int clip[TABLE_N_AXES][2],
 797                    int *widthp, int *heightp)
 798 {
 799   *widthp = 0;
 800   *heightp = 0;
 801
 802   /* Get the basic textual contents. */
 803   const char *plain_text = (cell->options & TAB_MARKUP
 804                             ? output_get_text_from_markup (cell->text)
 805                             : cell->text);
 806
 807   /* Append footnote markers if any. */
 808   const char *text;
 809   if (cell->n_footnotes)
 810     {
 811       text = add_footnote_markers (plain_text, cell);
 812       if (plain_text != cell->text)
 813         free (CONST_CAST (char *, plain_text));
 814     }
 815   else
 816     text = plain_text;
 817
 818   /* Calculate length; if it's zero, then there's nothing to do. */
 819   size_t length = strlen (text);
 820   if (!length)
 821     {
 822       if (text != cell->text)
 823         free (CONST_CAST (char *, text));
 824       return;
 825     }
 826
 827   char *breaks = xmalloc (length + 1);
 828   u8_possible_linebreaks (CHAR_CAST (const uint8_t *, text), length,
 829                           "UTF-8", breaks);
 830   breaks[length] = (breaks[length - 1] == UC_BREAK_MANDATORY
 831                     ? UC_BREAK_PROHIBITED : UC_BREAK_POSSIBLE);
 832
 833   size_t pos = 0;
 834   int bb_width = bb[H][1] - bb[H][0];
 835   for (int y = bb[V][0]; y < bb[V][1] && pos < length; y++)
 836     {
 837       const uint8_t *line = CHAR_CAST (const uint8_t *, text + pos);
 838       const char *b = breaks + pos;
 839       size_t n = length - pos;
 840
 841       size_t last_break_ofs = 0;
 842       int last_break_width = 0;
 843       int width = 0;
 844       size_t graph_ofs;
 845       size_t ofs;
 846
 847       for (ofs = 0; ofs < n; )
 848         {
 849           ucs4_t uc;
 850           int mblen;
 851           int w;
 852
 853           mblen = u8_mbtouc (&uc, line + ofs, n - ofs);
 854           if (b[ofs] == UC_BREAK_MANDATORY)
 855             break;
 856           else if (b[ofs] == UC_BREAK_POSSIBLE)
 857             {
 858               last_break_ofs = ofs;
 859               last_break_width = width;
 860             }
 861
 862           w = uc_width (uc, "UTF-8");
 863           if (w > 0)
 864             {
 865               if (width + w > bb_width)
 866                 {
 867                   if (isspace (line[ofs]))
 868                     break;
 869                   else if (last_break_ofs != 0)
 870                     {
 871                       ofs = last_break_ofs;
 872                       width = last_break_width;
 873                       break;
 874                     }
 875                 }
 876               width += w;
 877             }
 878           ofs += mblen;
 879         }
 880
 881       /* Trim any trailing spaces off the end of the text to be drawn. */
 882       for (graph_ofs = ofs; graph_ofs > 0; graph_ofs--)
 883         if (!isspace (line[graph_ofs - 1]))
 884           break;
 885       width -= ofs - graph_ofs;
 886
 887       /* Draw text. */
 888       text_draw (a, cell->style->cell_style.halign, cell->options,
 889                  cell->style->font_style.bold,
 890                  cell->style->font_style.underline,
 891                  bb, clip, y, line, graph_ofs, width);
 892
 893       /* If a new-line ended the line, just skip the new-line.  Otherwise, skip
 894          past any spaces past the end of the line (but not past a new-line). */
 895       if (b[ofs] == UC_BREAK_MANDATORY)
 896         ofs++;
 897       else
 898         while (ofs < n && isspace (line[ofs]) && b[ofs] != UC_BREAK_MANDATORY)
 899           ofs++;
 900
 901       if (width > *widthp)
 902         *widthp = width;
 903       ++*heightp;
 904       pos += ofs;
 905     }
 906
 907   free (breaks);
 908   if (text != cell->text)
 909     free (CONST_CAST (char *, text));
 910 }
 911
 912 void
 913 ascii_test_write (struct output_driver *driver,
 914                   const char *s, int x, int y, bool bold, bool underline)
 915 {
 916   struct ascii_driver *a = ascii_driver_cast (driver);
 917   int bb[TABLE_N_AXES][2];
 918   int width, height;
 919
 920   if (a->file == NULL && !ascii_open_page (a))
 921     return;
 922
 923   struct area_style style = {
 924     .cell_style.halign = TABLE_HALIGN_LEFT,
 925     .font_style.bold = bold,
 926     .font_style.underline = underline,
 927   };
 928   struct table_cell cell = {
 929     .text = CONST_CAST (char *, s),
 930     .style = &style,
 931   };
 932
 933   bb[TABLE_HORZ][0] = x;
 934   bb[TABLE_HORZ][1] = a->width;
 935   bb[TABLE_VERT][0] = y;
 936   bb[TABLE_VERT][1] = INT_MAX;
 937
 938   ascii_layout_cell (a, &cell, bb, bb, &width, &height);
 939 }
 940
 941 void
 942 ascii_test_set_length (struct output_driver *driver, int y, int length)
 943 {
 944   struct ascii_driver *a = ascii_driver_cast (driver);
 945
 946   if (a->file == NULL && !ascii_open_page (a))
 947     return;
 948
 949   if (y < 0)
 950     return;
 951   u8_line_set_length (&a->lines[y], length);
 952 }
 953
 954 void
 955 ascii_test_flush (struct output_driver *driver)
 956 {
 957   struct ascii_driver *a = ascii_driver_cast (driver);
 958
 959   for (size_t i = a->allocated_lines; i-- > 0; )
 960     if (a->lines[i].width)
 961       {
 962         ascii_output_lines (a, i + 1);
 963         break;
 964       }
 965 }
 966 \f
 967 /* ascii_close_page () and support routines. */
 968
 969 #if HAVE_DECL_SIGWINCH
 970 static struct ascii_driver *the_driver;
 971
 972 static void
 973 winch_handler (int signum UNUSED)
 974 {
 975   update_page_size (the_driver, false);
 976 }
 977 #endif
 978
 979 static bool
 980 ascii_open_page (struct ascii_driver *a)
 981 {
 982   if (a->error)
 983     return false;
 984
 985   if (a->file == NULL)
 986     {
 987       a->file = fn_open (a->handle, a->append ? "a" : "w");
 988       if (a->file != NULL)
 989         {
 990           if ( isatty (fileno (a->file)))
 991             {
 992 #if HAVE_DECL_SIGWINCH
 993               struct sigaction action;
 994               sigemptyset (&action.sa_mask);
 995               action.sa_flags = 0;
 996               action.sa_handler = winch_handler;
 997               the_driver = a;
 998               sigaction (SIGWINCH, &action, NULL);
 999 #endif
1000               a->auto_width = true;
1001             }
1002         }
1003       else
1004         {
1005           msg_error (errno, _("ascii: opening output file `%s'"),
1006                      fh_get_file_name (a->handle));
1007           a->error = true;
1008           return false;
1009         }
1010     }
1011
1012   return true;
1013 }