contrib/mdocml/term.c

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