contrib/mdocml/term.c

   1 /*      $Id: term.c,v 1.268 2017/06/08 12:54:58 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010-2017 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include "config.h"
  19
  20 #include <sys/types.h>
  21
  22 #include <assert.h>
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "mandoc.h"
  29 #include "mandoc_aux.h"
  30 #include "out.h"
  31 #include "term.h"
  32 #include "main.h"
  33
  34 static  size_t           cond_width(const struct termp *, int, int *);
  35 static  void             adjbuf(struct termp_col *, size_t);
  36 static  void             bufferc(struct termp *, char);
  37 static  void             encode(struct termp *, const char *, size_t);
  38 static  void             encode1(struct termp *, int);
  39 static  void             endline(struct termp *);
  40
  41
  42 void
  43 term_free(struct termp *p)
  44 {
  45         for (p->tcol = p->tcols; p->tcol < p->tcols + p->maxtcol; p->tcol++)
  46                 free(p->tcol->buf);
  47         free(p->tcols);
  48         free(p->fontq);
  49         free(p);
  50 }
  51
  52 void
  53 term_begin(struct termp *p, term_margin head,
  54                 term_margin foot, const struct roff_meta *arg)
  55 {
  56
  57         p->headf = head;
  58         p->footf = foot;
  59         p->argf = arg;
  60         (*p->begin)(p);
  61 }
  62
  63 void
  64 term_end(struct termp *p)
  65 {
  66
  67         (*p->end)(p);
  68 }
  69
  70 /*
  71  * Flush a chunk of text.  By default, break the output line each time
  72  * the right margin is reached, and continue output on the next line
  73  * at the same offset as the chunk itself.  By default, also break the
  74  * output line at the end of the chunk.
  75  * The following flags may be specified:
  76  *
  77  *  - TERMP_NOBREAK: Do not break the output line at the right margin,
  78  *    but only at the max right margin.  Also, do not break the output
  79  *    line at the end of the chunk, such that the next call can pad to
  80  *    the next column.  However, if less than p->trailspace blanks,
  81  *    which can be 0, 1, or 2, remain to the right margin, the line
  82  *    will be broken.
  83  *  - TERMP_BRTRSP: Consider trailing whitespace significant
  84  *    when deciding whether the chunk fits or not.
  85  *  - TERMP_BRIND: If the chunk does not fit and the output line has
  86  *    to be broken, start the next line at the right margin instead
  87  *    of at the offset.  Used together with TERMP_NOBREAK for the tags
  88  *    in various kinds of tagged lists.
  89  *  - TERMP_HANG: Do not break the output line at the right margin,
  90  *    append the next chunk after it even if this one is too long.
  91  *    To be used together with TERMP_NOBREAK.
  92  *  - TERMP_NOPAD: Start writing at the current position,
  93  *    do not pad with blank characters up to the offset.
  94  */
  95 void
  96 term_flushln(struct termp *p)
  97 {
  98         size_t           vis;   /* current visual position on output */
  99         size_t           vbl;   /* number of blanks to prepend to output */
 100         size_t           vend;  /* end of word visual position on output */
 101         size_t           bp;    /* visual right border position */
 102         size_t           dv;    /* temporary for visual pos calculations */
 103         size_t           j;     /* temporary loop index for p->tcol->buf */
 104         size_t           jhy;   /* last hyph before overflow w/r/t j */
 105         size_t           maxvis; /* output position of visible boundary */
 106         int              ntab;  /* number of tabs to prepend */
 107
 108         vbl = (p->flags & TERMP_NOPAD) || p->tcol->offset < p->viscol ?
 109             0 : p->tcol->offset - p->viscol;
 110         if (p->minbl && vbl < p->minbl)
 111                 vbl = p->minbl;
 112         maxvis = p->tcol->rmargin > p->viscol + vbl ?
 113             p->tcol->rmargin - p->viscol - vbl : 0;
 114         bp = !(p->flags & TERMP_NOBREAK) ? maxvis :
 115             p->maxrmargin > p->viscol + vbl ?
 116             p->maxrmargin - p->viscol - vbl : 0;
 117         vis = vend = 0;
 118
 119         if (p->lasttcol == 0)
 120                 p->tcol->col = 0;
 121         while (p->tcol->col < p->lastcol) {
 122
 123                 /*
 124                  * Handle literal tab characters: collapse all
 125                  * subsequent tabs into a single huge set of spaces.
 126                  */
 127
 128                 ntab = 0;
 129                 while (p->tcol->col < p->lastcol &&
 130                     p->tcol->buf[p->tcol->col] == '\t') {
 131                         vend = term_tab_next(vis);
 132                         vbl += vend - vis;
 133                         vis = vend;
 134                         ntab++;
 135                         p->tcol->col++;
 136                 }
 137
 138                 /*
 139                  * Count up visible word characters.  Control sequences
 140                  * (starting with the CSI) aren't counted.  A space
 141                  * generates a non-printing word, which is valid (the
 142                  * space is printed according to regular spacing rules).
 143                  */
 144
 145                 jhy = 0;
 146                 for (j = p->tcol->col; j < p->lastcol; j++) {
 147                         if (p->tcol->buf[j] == ' ' || p->tcol->buf[j] == '\t')
 148                                 break;
 149
 150                         /* Back over the last printed character. */
 151                         if (p->tcol->buf[j] == '\b') {
 152                                 assert(j);
 153                                 vend -= (*p->width)(p, p->tcol->buf[j - 1]);
 154                                 continue;
 155                         }
 156
 157                         /* Regular word. */
 158                         /* Break at the hyphen point if we overrun. */
 159                         if (vend > vis && vend < bp &&
 160                             (p->tcol->buf[j] == ASCII_HYPH||
 161                              p->tcol->buf[j] == ASCII_BREAK))
 162                                 jhy = j;
 163
 164                         /*
 165                          * Hyphenation now decided, put back a real
 166                          * hyphen such that we get the correct width.
 167                          */
 168                         if (p->tcol->buf[j] == ASCII_HYPH)
 169                                 p->tcol->buf[j] = '-';
 170
 171                         vend += (*p->width)(p, p->tcol->buf[j]);
 172                 }
 173
 174                 /*
 175                  * Find out whether we would exceed the right margin.
 176                  * If so, break to the next line.
 177                  */
 178
 179                 if (vend > bp && jhy == 0 && vis > 0 &&
 180                     (p->flags & TERMP_BRNEVER) == 0) {
 181                         if (p->lasttcol)
 182                                 return;
 183
 184                         endline(p);
 185                         vend -= vis;
 186
 187                         /* Use pending tabs on the new line. */
 188
 189                         vbl = 0;
 190                         while (ntab--)
 191                                 vbl = term_tab_next(vbl);
 192
 193                         /* Re-establish indentation. */
 194
 195                         if (p->flags & TERMP_BRIND)
 196                                 vbl += p->tcol->rmargin;
 197                         else
 198                                 vbl += p->tcol->offset;
 199                         maxvis = p->tcol->rmargin > vbl ?
 200                             p->tcol->rmargin - vbl : 0;
 201                         bp = !(p->flags & TERMP_NOBREAK) ? maxvis :
 202                             p->maxrmargin > vbl ?  p->maxrmargin - vbl : 0;
 203                 }
 204
 205                 /*
 206                  * Write out the rest of the word.
 207                  */
 208
 209                 for ( ; p->tcol->col < p->lastcol; p->tcol->col++) {
 210                         if (vend > bp && jhy > 0 && p->tcol->col > jhy)
 211                                 break;
 212                         if (p->tcol->buf[p->tcol->col] == '\t')
 213                                 break;
 214                         if (p->tcol->buf[p->tcol->col] == ' ') {
 215                                 j = p->tcol->col;
 216                                 while (p->tcol->col < p->lastcol &&
 217                                     p->tcol->buf[p->tcol->col] == ' ')
 218                                         p->tcol->col++;
 219                                 dv = (p->tcol->col - j) * (*p->width)(p, ' ');
 220                                 vbl += dv;
 221                                 vend += dv;
 222                                 break;
 223                         }
 224                         if (p->tcol->buf[p->tcol->col] == ASCII_NBRSP) {
 225                                 vbl += (*p->width)(p, ' ');
 226                                 continue;
 227                         }
 228                         if (p->tcol->buf[p->tcol->col] == ASCII_BREAK)
 229                                 continue;
 230
 231                         /*
 232                          * Now we definitely know there will be
 233                          * printable characters to output,
 234                          * so write preceding white space now.
 235                          */
 236                         if (vbl) {
 237                                 (*p->advance)(p, vbl);
 238                                 p->viscol += vbl;
 239                                 vbl = 0;
 240                         }
 241
 242                         (*p->letter)(p, p->tcol->buf[p->tcol->col]);
 243                         if (p->tcol->buf[p->tcol->col] == '\b')
 244                                 p->viscol -= (*p->width)(p,
 245                                     p->tcol->buf[p->tcol->col - 1]);
 246                         else
 247                                 p->viscol += (*p->width)(p,
 248                                     p->tcol->buf[p->tcol->col]);
 249                 }
 250                 vis = vend;
 251         }
 252
 253         /*
 254          * If there was trailing white space, it was not printed;
 255          * so reset the cursor position accordingly.
 256          */
 257
 258         if (vis > vbl)
 259                 vis -= vbl;
 260         else
 261                 vis = 0;
 262
 263         p->col = p->lastcol = 0;
 264         p->minbl = p->trailspace;
 265         p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE | TERMP_NOPAD);
 266
 267         /* Trailing whitespace is significant in some columns. */
 268
 269         if (vis && vbl && (TERMP_BRTRSP & p->flags))
 270                 vis += vbl;
 271
 272         /* If the column was overrun, break the line. */
 273         if ((p->flags & TERMP_NOBREAK) == 0 ||
 274             ((p->flags & TERMP_HANG) == 0 &&
 275              vis + p->trailspace * (*p->width)(p, ' ') > maxvis))
 276                 endline(p);
 277 }
 278
 279 static void
 280 endline(struct termp *p)
 281 {
 282         if ((p->flags & (TERMP_NEWMC | TERMP_ENDMC)) == TERMP_ENDMC) {
 283                 p->mc = NULL;
 284                 p->flags &= ~TERMP_ENDMC;
 285         }
 286         if (p->mc != NULL) {
 287                 if (p->viscol && p->maxrmargin >= p->viscol)
 288                         (*p->advance)(p, p->maxrmargin - p->viscol + 1);
 289                 p->flags |= TERMP_NOBUF | TERMP_NOSPACE;
 290                 term_word(p, p->mc);
 291                 p->flags &= ~(TERMP_NOBUF | TERMP_NEWMC);
 292         }
 293         p->viscol = 0;
 294         p->minbl = 0;
 295         (*p->endline)(p);
 296 }
 297
 298 /*
 299  * A newline only breaks an existing line; it won't assert vertical
 300  * space.  All data in the output buffer is flushed prior to the newline
 301  * assertion.
 302  */
 303 void
 304 term_newln(struct termp *p)
 305 {
 306
 307         p->flags |= TERMP_NOSPACE;
 308         if (p->lastcol || p->viscol)
 309                 term_flushln(p);
 310 }
 311
 312 /*
 313  * Asserts a vertical space (a full, empty line-break between lines).
 314  * Note that if used twice, this will cause two blank spaces and so on.
 315  * All data in the output buffer is flushed prior to the newline
 316  * assertion.
 317  */
 318 void
 319 term_vspace(struct termp *p)
 320 {
 321
 322         term_newln(p);
 323         p->viscol = 0;
 324         p->minbl = 0;
 325         if (0 < p->skipvsp)
 326                 p->skipvsp--;
 327         else
 328                 (*p->endline)(p);
 329 }
 330
 331 /* Swap current and previous font; for \fP and .ft P */
 332 void
 333 term_fontlast(struct termp *p)
 334 {
 335         enum termfont    f;
 336
 337         f = p->fontl;
 338         p->fontl = p->fontq[p->fonti];
 339         p->fontq[p->fonti] = f;
 340 }
 341
 342 /* Set font, save current, discard previous; for \f, .ft, .B etc. */
 343 void
 344 term_fontrepl(struct termp *p, enum termfont f)
 345 {
 346
 347         p->fontl = p->fontq[p->fonti];
 348         p->fontq[p->fonti] = f;
 349 }
 350
 351 /* Set font, save previous. */
 352 void
 353 term_fontpush(struct termp *p, enum termfont f)
 354 {
 355
 356         p->fontl = p->fontq[p->fonti];
 357         if (++p->fonti == p->fontsz) {
 358                 p->fontsz += 8;
 359                 p->fontq = mandoc_reallocarray(p->fontq,
 360                     p->fontsz, sizeof(*p->fontq));
 361         }
 362         p->fontq[p->fonti] = f;
 363 }
 364
 365 /* Flush to make the saved pointer current again. */
 366 void
 367 term_fontpopq(struct termp *p, int i)
 368 {
 369
 370         assert(i >= 0);
 371         if (p->fonti > i)
 372                 p->fonti = i;
 373 }
 374
 375 /* Pop one font off the stack. */
 376 void
 377 term_fontpop(struct termp *p)
 378 {
 379
 380         assert(p->fonti);
 381         p->fonti--;
 382 }
 383
 384 /*
 385  * Handle pwords, partial words, which may be either a single word or a
 386  * phrase that cannot be broken down (such as a literal string).  This
 387  * handles word styling.
 388  */
 389 void
 390 term_word(struct termp *p, const char *word)
 391 {
 392         struct roffsu    su;
 393         const char       nbrsp[2] = { ASCII_NBRSP, 0 };
 394         const char      *seq, *cp;
 395         int              sz, uc;
 396         size_t           csz, lsz, ssz;
 397         enum mandoc_esc  esc;
 398
 399         if ((p->flags & TERMP_NOBUF) == 0) {
 400                 if ((p->flags & TERMP_NOSPACE) == 0) {
 401                         if ((p->flags & TERMP_KEEP) == 0) {
 402                                 bufferc(p, ' ');
 403                                 if (p->flags & TERMP_SENTENCE)
 404                                         bufferc(p, ' ');
 405                         } else
 406                                 bufferc(p, ASCII_NBRSP);
 407                 }
 408                 if (p->flags & TERMP_PREKEEP)
 409                         p->flags |= TERMP_KEEP;
 410                 if (p->flags & TERMP_NONOSPACE)
 411                         p->flags |= TERMP_NOSPACE;
 412                 else
 413                         p->flags &= ~TERMP_NOSPACE;
 414                 p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);
 415                 p->skipvsp = 0;
 416         }
 417
 418         while ('\0' != *word) {
 419                 if ('\\' != *word) {
 420                         if (TERMP_NBRWORD & p->flags) {
 421                                 if (' ' == *word) {
 422                                         encode(p, nbrsp, 1);
 423                                         word++;
 424                                         continue;
 425                                 }
 426                                 ssz = strcspn(word, "\\ ");
 427                         } else
 428                                 ssz = strcspn(word, "\\");
 429                         encode(p, word, ssz);
 430                         word += (int)ssz;
 431                         continue;
 432                 }
 433
 434                 word++;
 435                 esc = mandoc_escape(&word, &seq, &sz);
 436                 if (ESCAPE_ERROR == esc)
 437                         continue;
 438
 439                 switch (esc) {
 440                 case ESCAPE_UNICODE:
 441                         uc = mchars_num2uc(seq + 1, sz - 1);
 442                         break;
 443                 case ESCAPE_NUMBERED:
 444                         uc = mchars_num2char(seq, sz);
 445                         if (uc < 0)
 446                                 continue;
 447                         break;
 448                 case ESCAPE_SPECIAL:
 449                         if (p->enc == TERMENC_ASCII) {
 450                                 cp = mchars_spec2str(seq, sz, &ssz);
 451                                 if (cp != NULL)
 452                                         encode(p, cp, ssz);
 453                         } else {
 454                                 uc = mchars_spec2cp(seq, sz);
 455                                 if (uc > 0)
 456                                         encode1(p, uc);
 457                         }
 458                         continue;
 459                 case ESCAPE_FONTBOLD:
 460                         term_fontrepl(p, TERMFONT_BOLD);
 461                         continue;
 462                 case ESCAPE_FONTITALIC:
 463                         term_fontrepl(p, TERMFONT_UNDER);
 464                         continue;
 465                 case ESCAPE_FONTBI:
 466                         term_fontrepl(p, TERMFONT_BI);
 467                         continue;
 468                 case ESCAPE_FONT:
 469                 case ESCAPE_FONTROMAN:
 470                         term_fontrepl(p, TERMFONT_NONE);
 471                         continue;
 472                 case ESCAPE_FONTPREV:
 473                         term_fontlast(p);
 474                         continue;
 475                 case ESCAPE_NOSPACE:
 476                         if (p->flags & TERMP_BACKAFTER)
 477                                 p->flags &= ~TERMP_BACKAFTER;
 478                         else if (*word == '\0')
 479                                 p->flags |= (TERMP_NOSPACE | TERMP_NONEWLINE);
 480                         continue;
 481                 case ESCAPE_HORIZ:
 482                         if (a2roffsu(seq, &su, SCALE_EM) == NULL)
 483                                 continue;
 484                         uc = term_hspan(p, &su) / 24;
 485                         if (uc > 0)
 486                                 while (uc-- > 0)
 487                                         bufferc(p, ASCII_NBRSP);
 488                         else if (p->col > (size_t)(-uc))
 489                                 p->col += uc;
 490                         else {
 491                                 uc += p->col;
 492                                 p->col = 0;
 493                                 if (p->tcol->offset > (size_t)(-uc)) {
 494                                         p->ti += uc;
 495                                         p->tcol->offset += uc;
 496                                 } else {
 497                                         p->ti -= p->tcol->offset;
 498                                         p->tcol->offset = 0;
 499                                 }
 500                         }
 501                         continue;
 502                 case ESCAPE_HLINE:
 503                         if ((seq = a2roffsu(seq, &su, SCALE_EM)) == NULL)
 504                                 continue;
 505                         uc = term_hspan(p, &su) / 24;
 506                         if (uc <= 0) {
 507                                 if (p->tcol->rmargin <= p->tcol->offset)
 508                                         continue;
 509                                 lsz = p->tcol->rmargin - p->tcol->offset;
 510                         } else
 511                                 lsz = uc;
 512                         if (*seq == '\0')
 513                                 uc = -1;
 514                         else if (*seq == '\\') {
 515                                 seq++;
 516                                 esc = mandoc_escape(&seq, &cp, &sz);
 517                                 switch (esc) {
 518                                 case ESCAPE_UNICODE:
 519                                         uc = mchars_num2uc(cp + 1, sz - 1);
 520                                         break;
 521                                 case ESCAPE_NUMBERED:
 522                                         uc = mchars_num2char(cp, sz);
 523                                         break;
 524                                 case ESCAPE_SPECIAL:
 525                                         uc = mchars_spec2cp(cp, sz);
 526                                         break;
 527                                 default:
 528                                         uc = -1;
 529                                         break;
 530                                 }
 531                         } else
 532                                 uc = *seq;
 533                         if (uc < 0x20 || (uc > 0x7E && uc < 0xA0))
 534                                 uc = '_';
 535                         if (p->enc == TERMENC_ASCII) {
 536                                 cp = ascii_uc2str(uc);
 537                                 csz = term_strlen(p, cp);
 538                                 ssz = strlen(cp);
 539                         } else
 540                                 csz = (*p->width)(p, uc);
 541                         while (lsz >= csz) {
 542                                 if (p->enc == TERMENC_ASCII)
 543                                         encode(p, cp, ssz);
 544                                 else
 545                                         encode1(p, uc);
 546                                 lsz -= csz;
 547                         }
 548                         continue;
 549                 case ESCAPE_SKIPCHAR:
 550                         p->flags |= TERMP_BACKAFTER;
 551                         continue;
 552                 case ESCAPE_OVERSTRIKE:
 553                         cp = seq + sz;
 554                         while (seq < cp) {
 555                                 if (*seq == '\\') {
 556                                         mandoc_escape(&seq, NULL, NULL);
 557                                         continue;
 558                                 }
 559                                 encode1(p, *seq++);
 560                                 if (seq < cp) {
 561                                         if (p->flags & TERMP_BACKBEFORE)
 562                                                 p->flags |= TERMP_BACKAFTER;
 563                                         else
 564                                                 p->flags |= TERMP_BACKBEFORE;
 565                                 }
 566                         }
 567                         /* Trim trailing backspace/blank pair. */
 568                         if (p->lastcol > 2 &&
 569                             (p->tcol->buf[p->lastcol - 1] == ' ' ||
 570                              p->tcol->buf[p->lastcol - 1] == '\t'))
 571                                 p->lastcol -= 2;
 572                         if (p->col > p->lastcol)
 573                                 p->col = p->lastcol;
 574                         continue;
 575                 default:
 576                         continue;
 577                 }
 578
 579                 /*
 580                  * Common handling for Unicode and numbered
 581                  * character escape sequences.
 582                  */
 583
 584                 if (p->enc == TERMENC_ASCII) {
 585                         cp = ascii_uc2str(uc);
 586                         encode(p, cp, strlen(cp));
 587                 } else {
 588                         if ((uc < 0x20 && uc != 0x09) ||
 589                             (uc > 0x7E && uc < 0xA0))
 590                                 uc = 0xFFFD;
 591                         encode1(p, uc);
 592                 }
 593         }
 594         p->flags &= ~TERMP_NBRWORD;
 595 }
 596
 597 static void
 598 adjbuf(struct termp_col *c, size_t sz)
 599 {
 600         if (c->maxcols == 0)
 601                 c->maxcols = 1024;
 602         while (c->maxcols <= sz)
 603                 c->maxcols <<= 2;
 604         c->buf = mandoc_reallocarray(c->buf, c->maxcols, sizeof(*c->buf));
 605 }
 606
 607 static void
 608 bufferc(struct termp *p, char c)
 609 {
 610         if (p->flags & TERMP_NOBUF) {
 611                 (*p->letter)(p, c);
 612                 return;
 613         }
 614         if (p->col + 1 >= p->tcol->maxcols)
 615                 adjbuf(p->tcol, p->col + 1);
 616         if (p->lastcol <= p->col || (c != ' ' && c != ASCII_NBRSP))
 617                 p->tcol->buf[p->col] = c;
 618         if (p->lastcol < ++p->col)
 619                 p->lastcol = p->col;
 620 }
 621
 622 /*
 623  * See encode().
 624  * Do this for a single (probably unicode) value.
 625  * Does not check for non-decorated glyphs.
 626  */
 627 static void
 628 encode1(struct termp *p, int c)
 629 {
 630         enum termfont     f;
 631
 632         if (p->flags & TERMP_NOBUF) {
 633                 (*p->letter)(p, c);
 634                 return;
 635         }
 636
 637         if (p->col + 7 >= p->tcol->maxcols)
 638                 adjbuf(p->tcol, p->col + 7);
 639
 640         f = (c == ASCII_HYPH || c > 127 || isgraph(c)) ?
 641             p->fontq[p->fonti] : TERMFONT_NONE;
 642
 643         if (p->flags & TERMP_BACKBEFORE) {
 644                 if (p->tcol->buf[p->col - 1] == ' ' ||
 645                     p->tcol->buf[p->col - 1] == '\t')
 646                         p->col--;
 647                 else
 648                         p->tcol->buf[p->col++] = '\b';
 649                 p->flags &= ~TERMP_BACKBEFORE;
 650         }
 651         if (f == TERMFONT_UNDER || f == TERMFONT_BI) {
 652                 p->tcol->buf[p->col++] = '_';
 653                 p->tcol->buf[p->col++] = '\b';
 654         }
 655         if (f == TERMFONT_BOLD || f == TERMFONT_BI) {
 656                 if (c == ASCII_HYPH)
 657                         p->tcol->buf[p->col++] = '-';
 658                 else
 659                         p->tcol->buf[p->col++] = c;
 660                 p->tcol->buf[p->col++] = '\b';
 661         }
 662         if (p->lastcol <= p->col || (c != ' ' && c != ASCII_NBRSP))
 663                 p->tcol->buf[p->col] = c;
 664         if (p->lastcol < ++p->col)
 665                 p->lastcol = p->col;
 666         if (p->flags & TERMP_BACKAFTER) {
 667                 p->flags |= TERMP_BACKBEFORE;
 668                 p->flags &= ~TERMP_BACKAFTER;
 669         }
 670 }
 671
 672 static void
 673 encode(struct termp *p, const char *word, size_t sz)
 674 {
 675         size_t            i;
 676
 677         if (p->flags & TERMP_NOBUF) {
 678                 for (i = 0; i < sz; i++)
 679                         (*p->letter)(p, word[i]);
 680                 return;
 681         }
 682
 683         if (p->col + 2 + (sz * 5) >= p->tcol->maxcols)
 684                 adjbuf(p->tcol, p->col + 2 + (sz * 5));
 685
 686         for (i = 0; i < sz; i++) {
 687                 if (ASCII_HYPH == word[i] ||
 688                     isgraph((unsigned char)word[i]))
 689                         encode1(p, word[i]);
 690                 else {
 691                         if (p->lastcol <= p->col ||
 692                             (word[i] != ' ' && word[i] != ASCII_NBRSP))
 693                                 p->tcol->buf[p->col] = word[i];
 694                         p->col++;
 695
 696                         /*
 697                          * Postpone the effect of \z while handling
 698                          * an overstrike sequence from ascii_uc2str().
 699                          */
 700
 701                         if (word[i] == '\b' &&
 702                             (p->flags & TERMP_BACKBEFORE)) {
 703                                 p->flags &= ~TERMP_BACKBEFORE;
 704                                 p->flags |= TERMP_BACKAFTER;
 705                         }
 706                 }
 707         }
 708         if (p->lastcol < p->col)
 709                 p->lastcol = p->col;
 710 }
 711
 712 void
 713 term_setwidth(struct termp *p, const char *wstr)
 714 {
 715         struct roffsu    su;
 716         int              iop, width;
 717
 718         iop = 0;
 719         width = 0;
 720         if (NULL != wstr) {
 721                 switch (*wstr) {
 722                 case '+':
 723                         iop = 1;
 724                         wstr++;
 725                         break;
 726                 case '-':
 727                         iop = -1;
 728                         wstr++;
 729                         break;
 730                 default:
 731                         break;
 732                 }
 733                 if (a2roffsu(wstr, &su, SCALE_MAX) != NULL)
 734                         width = term_hspan(p, &su);
 735                 else
 736                         iop = 0;
 737         }
 738         (*p->setwidth)(p, iop, width);
 739 }
 740
 741 size_t
 742 term_len(const struct termp *p, size_t sz)
 743 {
 744
 745         return (*p->width)(p, ' ') * sz;
 746 }
 747
 748 static size_t
 749 cond_width(const struct termp *p, int c, int *skip)
 750 {
 751
 752         if (*skip) {
 753                 (*skip) = 0;
 754                 return 0;
 755         } else
 756                 return (*p->width)(p, c);
 757 }
 758
 759 size_t
 760 term_strlen(const struct termp *p, const char *cp)
 761 {
 762         size_t           sz, rsz, i;
 763         int              ssz, skip, uc;
 764         const char      *seq, *rhs;
 765         enum mandoc_esc  esc;
 766         static const char rej[] = { '\\', ASCII_NBRSP, ASCII_HYPH,
 767                         ASCII_BREAK, '\0' };
 768
 769         /*
 770          * Account for escaped sequences within string length
 771          * calculations.  This follows the logic in term_word() as we
 772          * must calculate the width of produced strings.
 773          */
 774
 775         sz = 0;
 776         skip = 0;
 777         while ('\0' != *cp) {
 778                 rsz = strcspn(cp, rej);
 779                 for (i = 0; i < rsz; i++)
 780                         sz += cond_width(p, *cp++, &skip);
 781
 782                 switch (*cp) {
 783                 case '\\':
 784                         cp++;
 785                         esc = mandoc_escape(&cp, &seq, &ssz);
 786                         if (ESCAPE_ERROR == esc)
 787                                 continue;
 788
 789                         rhs = NULL;
 790
 791                         switch (esc) {
 792                         case ESCAPE_UNICODE:
 793                                 uc = mchars_num2uc(seq + 1, ssz - 1);
 794                                 break;
 795                         case ESCAPE_NUMBERED:
 796                                 uc = mchars_num2char(seq, ssz);
 797                                 if (uc < 0)
 798                                         continue;
 799                                 break;
 800                         case ESCAPE_SPECIAL:
 801                                 if (p->enc == TERMENC_ASCII) {
 802                                         rhs = mchars_spec2str(seq, ssz, &rsz);
 803                                         if (rhs != NULL)
 804                                                 break;
 805                                 } else {
 806                                         uc = mchars_spec2cp(seq, ssz);
 807                                         if (uc > 0)
 808                                                 sz += cond_width(p, uc, &skip);
 809                                 }
 810                                 continue;
 811                         case ESCAPE_SKIPCHAR:
 812                                 skip = 1;
 813                                 continue;
 814                         case ESCAPE_OVERSTRIKE:
 815                                 rsz = 0;
 816                                 rhs = seq + ssz;
 817                                 while (seq < rhs) {
 818                                         if (*seq == '\\') {
 819                                                 mandoc_escape(&seq, NULL, NULL);
 820                                                 continue;
 821                                         }
 822                                         i = (*p->width)(p, *seq++);
 823                                         if (rsz < i)
 824                                                 rsz = i;
 825                                 }
 826                                 sz += rsz;
 827                                 continue;
 828                         default:
 829                                 continue;
 830                         }
 831
 832                         /*
 833                          * Common handling for Unicode and numbered
 834                          * character escape sequences.
 835                          */
 836
 837                         if (rhs == NULL) {
 838                                 if (p->enc == TERMENC_ASCII) {
 839                                         rhs = ascii_uc2str(uc);
 840                                         rsz = strlen(rhs);
 841                                 } else {
 842                                         if ((uc < 0x20 && uc != 0x09) ||
 843                                             (uc > 0x7E && uc < 0xA0))
 844                                                 uc = 0xFFFD;
 845                                         sz += cond_width(p, uc, &skip);
 846                                         continue;
 847                                 }
 848                         }
 849
 850                         if (skip) {
 851                                 skip = 0;
 852                                 break;
 853                         }
 854
 855                         /*
 856                          * Common handling for all escape sequences
 857                          * printing more than one character.
 858                          */
 859
 860                         for (i = 0; i < rsz; i++)
 861                                 sz += (*p->width)(p, *rhs++);
 862                         break;
 863                 case ASCII_NBRSP:
 864                         sz += cond_width(p, ' ', &skip);
 865                         cp++;
 866                         break;
 867                 case ASCII_HYPH:
 868                         sz += cond_width(p, '-', &skip);
 869                         cp++;
 870                         break;
 871                 default:
 872                         break;
 873                 }
 874         }
 875
 876         return sz;
 877 }
 878
 879 int
 880 term_vspan(const struct termp *p, const struct roffsu *su)
 881 {
 882         double           r;
 883         int              ri;
 884
 885         switch (su->unit) {
 886         case SCALE_BU:
 887                 r = su->scale / 40.0;
 888                 break;
 889         case SCALE_CM:
 890                 r = su->scale * 6.0 / 2.54;
 891                 break;
 892         case SCALE_FS:
 893                 r = su->scale * 65536.0 / 40.0;
 894                 break;
 895         case SCALE_IN:
 896                 r = su->scale * 6.0;
 897                 break;
 898         case SCALE_MM:
 899                 r = su->scale * 0.006;
 900                 break;
 901         case SCALE_PC:
 902                 r = su->scale;
 903                 break;
 904         case SCALE_PT:
 905                 r = su->scale / 12.0;
 906                 break;
 907         case SCALE_EN:
 908         case SCALE_EM:
 909                 r = su->scale * 0.6;
 910                 break;
 911         case SCALE_VS:
 912                 r = su->scale;
 913                 break;
 914         default:
 915                 abort();
 916         }
 917         ri = r > 0.0 ? r + 0.4995 : r - 0.4995;
 918         return ri < 66 ? ri : 1;
 919 }
 920
 921 /*
 922  * Convert a scaling width to basic units, rounding down.
 923  */
 924 int
 925 term_hspan(const struct termp *p, const struct roffsu *su)
 926 {
 927
 928         return (*p->hspan)(p, su);
 929 }