term.c

   1 /*      $Id: term.c,v 1.205 2012/07/16 21:30:42 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2011, 2012 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 AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR 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 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <sys/types.h>
  23
  24 #include <assert.h>
  25 #include <ctype.h>
  26 #include <stdint.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "mandoc.h"
  32 #include "out.h"
  33 #include "term.h"
  34 #include "main.h"
  35
  36 static  size_t           cond_width(const struct termp *, int, int *);
  37 static  void             adjbuf(struct termp *p, int);
  38 static  void             bufferc(struct termp *, char);
  39 static  void             encode(struct termp *, const char *, size_t);
  40 static  void             encode1(struct termp *, int);
  41
  42 void
  43 term_free(struct termp *p)
  44 {
  45
  46         if (p->buf)
  47                 free(p->buf);
  48         if (p->symtab)
  49                 mchars_free(p->symtab);
  50
  51         free(p);
  52 }
  53
  54
  55 void
  56 term_begin(struct termp *p, term_margin head,
  57                 term_margin foot, const void *arg)
  58 {
  59
  60         p->headf = head;
  61         p->footf = foot;
  62         p->argf = arg;
  63         (*p->begin)(p);
  64 }
  65
  66
  67 void
  68 term_end(struct termp *p)
  69 {
  70
  71         (*p->end)(p);
  72 }
  73
  74 /*
  75  * Flush a line of text.  A "line" is loosely defined as being something
  76  * that should be followed by a newline, regardless of whether it's
  77  * broken apart by newlines getting there.  A line can also be a
  78  * fragment of a columnar list (`Bl -tag' or `Bl -column'), which does
  79  * not have a trailing newline.
  80  *
  81  * The following flags may be specified:
  82  *
  83  *  - TERMP_NOBREAK: this is the most important and is used when making
  84  *    columns.  In short: don't print a newline and instead expect the
  85  *    next call to do the padding up to the start of the next column.
  86  *
  87  *  - TERMP_TWOSPACE: make sure there is room for at least two space
  88  *    characters of padding.  Otherwise, rather break the line.
  89  *
  90  *  - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and
  91  *    the line is overrun, and don't pad-right if it's underrun.
  92  *
  93  *  - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when
  94  *    overrunning, instead save the position and continue at that point
  95  *    when the next invocation.
  96  *
  97  *  In-line line breaking:
  98  *
  99  *  If TERMP_NOBREAK is specified and the line overruns the right
 100  *  margin, it will break and pad-right to the right margin after
 101  *  writing.  If maxrmargin is violated, it will break and continue
 102  *  writing from the right-margin, which will lead to the above scenario
 103  *  upon exit.  Otherwise, the line will break at the right margin.
 104  */
 105 void
 106 term_flushln(struct termp *p)
 107 {
 108         int              i;     /* current input position in p->buf */
 109         int              ntab;  /* number of tabs to prepend */
 110         size_t           vis;   /* current visual position on output */
 111         size_t           vbl;   /* number of blanks to prepend to output */
 112         size_t           vend;  /* end of word visual position on output */
 113         size_t           bp;    /* visual right border position */
 114         size_t           dv;    /* temporary for visual pos calculations */
 115         int              j;     /* temporary loop index for p->buf */
 116         int              jhy;   /* last hyph before overflow w/r/t j */
 117         size_t           maxvis; /* output position of visible boundary */
 118         size_t           mmax; /* used in calculating bp */
 119
 120         /*
 121          * First, establish the maximum columns of "visible" content.
 122          * This is usually the difference between the right-margin and
 123          * an indentation, but can be, for tagged lists or columns, a
 124          * small set of values.
 125          */
 126         assert  (p->rmargin >= p->offset);
 127         dv     = p->rmargin - p->offset;
 128         maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;
 129         dv     = p->maxrmargin - p->offset;
 130         mmax   = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;
 131
 132         bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
 133
 134         /*
 135          * Calculate the required amount of padding.
 136          */
 137         vbl = p->offset + p->overstep > p->viscol ?
 138               p->offset + p->overstep - p->viscol : 0;
 139
 140         vis = vend = 0;
 141         i = 0;
 142
 143         while (i < p->col) {
 144                 /*
 145                  * Handle literal tab characters: collapse all
 146                  * subsequent tabs into a single huge set of spaces.
 147                  */
 148                 ntab = 0;
 149                 while (i < p->col && '\t' == p->buf[i]) {
 150                         vend = (vis / p->tabwidth + 1) * p->tabwidth;
 151                         vbl += vend - vis;
 152                         vis = vend;
 153                         ntab++;
 154                         i++;
 155                 }
 156
 157                 /*
 158                  * Count up visible word characters.  Control sequences
 159                  * (starting with the CSI) aren't counted.  A space
 160                  * generates a non-printing word, which is valid (the
 161                  * space is printed according to regular spacing rules).
 162                  */
 163
 164                 for (j = i, jhy = 0; j < p->col; j++) {
 165                         if ((j && ' ' == p->buf[j]) || '\t' == p->buf[j])
 166                                 break;
 167
 168                         /* Back over the the last printed character. */
 169                         if (8 == p->buf[j]) {
 170                                 assert(j);
 171                                 vend -= (*p->width)(p, p->buf[j - 1]);
 172                                 continue;
 173                         }
 174
 175                         /* Regular word. */
 176                         /* Break at the hyphen point if we overrun. */
 177                         if (vend > vis && vend < bp &&
 178                                         ASCII_HYPH == p->buf[j])
 179                                 jhy = j;
 180
 181                         vend += (*p->width)(p, p->buf[j]);
 182                 }
 183
 184                 /*
 185                  * Find out whether we would exceed the right margin.
 186                  * If so, break to the next line.
 187                  */
 188                 if (vend > bp && 0 == jhy && vis > 0) {
 189                         vend -= vis;
 190                         (*p->endline)(p);
 191                         p->viscol = 0;
 192                         if (TERMP_NOBREAK & p->flags) {
 193                                 vbl = p->rmargin;
 194                                 vend += p->rmargin - p->offset;
 195                         } else
 196                                 vbl = p->offset;
 197
 198                         /* use pending tabs on the new line */
 199
 200                         if (0 < ntab)
 201                                 vbl += ntab * p->tabwidth;
 202
 203                         /* Remove the p->overstep width. */
 204
 205                         bp += (size_t)p->overstep;
 206                         p->overstep = 0;
 207                 }
 208
 209                 /* Write out the [remaining] word. */
 210                 for ( ; i < p->col; i++) {
 211                         if (vend > bp && jhy > 0 && i > jhy)
 212                                 break;
 213                         if ('\t' == p->buf[i])
 214                                 break;
 215                         if (' ' == p->buf[i]) {
 216                                 j = i;
 217                                 while (' ' == p->buf[i])
 218                                         i++;
 219                                 dv = (size_t)(i - j) * (*p->width)(p, ' ');
 220                                 vbl += dv;
 221                                 vend += dv;
 222                                 break;
 223                         }
 224                         if (ASCII_NBRSP == p->buf[i]) {
 225                                 vbl += (*p->width)(p, ' ');
 226                                 continue;
 227                         }
 228
 229                         /*
 230                          * Now we definitely know there will be
 231                          * printable characters to output,
 232                          * so write preceding white space now.
 233                          */
 234                         if (vbl) {
 235                                 (*p->advance)(p, vbl);
 236                                 p->viscol += vbl;
 237                                 vbl = 0;
 238                         }
 239
 240                         if (ASCII_HYPH == p->buf[i]) {
 241                                 (*p->letter)(p, '-');
 242                                 p->viscol += (*p->width)(p, '-');
 243                                 continue;
 244                         }
 245
 246                         (*p->letter)(p, p->buf[i]);
 247                         if (8 == p->buf[i])
 248                                 p->viscol -= (*p->width)(p, p->buf[i-1]);
 249                         else
 250                                 p->viscol += (*p->width)(p, p->buf[i]);
 251                 }
 252                 vis = vend;
 253         }
 254
 255         /*
 256          * If there was trailing white space, it was not printed;
 257          * so reset the cursor position accordingly.
 258          */
 259         if (vis)
 260                 vis -= vbl;
 261
 262         p->col = 0;
 263         p->overstep = 0;
 264
 265         if ( ! (TERMP_NOBREAK & p->flags)) {
 266                 p->viscol = 0;
 267                 (*p->endline)(p);
 268                 return;
 269         }
 270
 271         if (TERMP_HANG & p->flags) {
 272                 /* We need one blank after the tag. */
 273                 p->overstep = (int)(vis - maxvis + (*p->width)(p, ' '));
 274
 275                 /*
 276                  * If we have overstepped the margin, temporarily move
 277                  * it to the right and flag the rest of the line to be
 278                  * shorter.
 279                  */
 280                 if (p->overstep < 0)
 281                         p->overstep = 0;
 282                 return;
 283
 284         } else if (TERMP_DANGLE & p->flags)
 285                 return;
 286
 287         /* If the column was overrun, break the line. */
 288         if (maxvis <= vis +
 289             ((TERMP_TWOSPACE & p->flags) ? (*p->width)(p, ' ') : 0)) {
 290                 (*p->endline)(p);
 291                 p->viscol = 0;
 292         }
 293 }
 294
 295
 296 /*
 297  * A newline only breaks an existing line; it won't assert vertical
 298  * space.  All data in the output buffer is flushed prior to the newline
 299  * assertion.
 300  */
 301 void
 302 term_newln(struct termp *p)
 303 {
 304
 305         p->flags |= TERMP_NOSPACE;
 306         if (p->col || p->viscol)
 307                 term_flushln(p);
 308 }
 309
 310
 311 /*
 312  * Asserts a vertical space (a full, empty line-break between lines).
 313  * Note that if used twice, this will cause two blank spaces and so on.
 314  * All data in the output buffer is flushed prior to the newline
 315  * assertion.
 316  */
 317 void
 318 term_vspace(struct termp *p)
 319 {
 320
 321         term_newln(p);
 322         p->viscol = 0;
 323         if (0 < p->skipvsp)
 324                 p->skipvsp--;
 325         else
 326                 (*p->endline)(p);
 327 }
 328
 329 void
 330 term_fontlast(struct termp *p)
 331 {
 332         enum termfont    f;
 333
 334         f = p->fontl;
 335         p->fontl = p->fontq[p->fonti];
 336         p->fontq[p->fonti] = f;
 337 }
 338
 339
 340 void
 341 term_fontrepl(struct termp *p, enum termfont f)
 342 {
 343
 344         p->fontl = p->fontq[p->fonti];
 345         p->fontq[p->fonti] = f;
 346 }
 347
 348
 349 void
 350 term_fontpush(struct termp *p, enum termfont f)
 351 {
 352
 353         assert(p->fonti + 1 < 10);
 354         p->fontl = p->fontq[p->fonti];
 355         p->fontq[++p->fonti] = f;
 356 }
 357
 358
 359 const void *
 360 term_fontq(struct termp *p)
 361 {
 362
 363         return(&p->fontq[p->fonti]);
 364 }
 365
 366
 367 enum termfont
 368 term_fonttop(struct termp *p)
 369 {
 370
 371         return(p->fontq[p->fonti]);
 372 }
 373
 374
 375 void
 376 term_fontpopq(struct termp *p, const void *key)
 377 {
 378
 379         while (p->fonti >= 0 && key != &p->fontq[p->fonti])
 380                 p->fonti--;
 381         assert(p->fonti >= 0);
 382 }
 383
 384
 385 void
 386 term_fontpop(struct termp *p)
 387 {
 388
 389         assert(p->fonti);
 390         p->fonti--;
 391 }
 392
 393 /*
 394  * Handle pwords, partial words, which may be either a single word or a
 395  * phrase that cannot be broken down (such as a literal string).  This
 396  * handles word styling.
 397  */
 398 void
 399 term_word(struct termp *p, const char *word)
 400 {
 401         const char      *seq, *cp;
 402         char             c;
 403         int              sz, uc;
 404         size_t           ssz;
 405         enum mandoc_esc  esc;
 406
 407         if ( ! (TERMP_NOSPACE & p->flags)) {
 408                 if ( ! (TERMP_KEEP & p->flags)) {
 409                         if (TERMP_PREKEEP & p->flags)
 410                                 p->flags |= TERMP_KEEP;
 411                         bufferc(p, ' ');
 412                         if (TERMP_SENTENCE & p->flags)
 413                                 bufferc(p, ' ');
 414                 } else
 415                         bufferc(p, ASCII_NBRSP);
 416         }
 417
 418         if ( ! (p->flags & TERMP_NONOSPACE))
 419                 p->flags &= ~TERMP_NOSPACE;
 420         else
 421                 p->flags |= TERMP_NOSPACE;
 422
 423         p->flags &= ~(TERMP_SENTENCE | TERMP_IGNDELIM);
 424
 425         while ('\0' != *word) {
 426                 if ('\\' != *word) {
 427                         if (TERMP_SKIPCHAR & p->flags) {
 428                                 p->flags &= ~TERMP_SKIPCHAR;
 429                                 word++;
 430                                 continue;
 431                         }
 432                         ssz = strcspn(word, "\\");
 433                         encode(p, word, ssz);
 434                         word += (int)ssz;
 435                         continue;
 436                 }
 437
 438                 word++;
 439                 esc = mandoc_escape(&word, &seq, &sz);
 440                 if (ESCAPE_ERROR == esc)
 441                         break;
 442
 443                 if (TERMENC_ASCII != p->enc)
 444                         switch (esc) {
 445                         case (ESCAPE_UNICODE):
 446                                 uc = mchars_num2uc(seq + 1, sz - 1);
 447                                 if ('\0' == uc)
 448                                         break;
 449                                 encode1(p, uc);
 450                                 continue;
 451                         case (ESCAPE_SPECIAL):
 452                                 uc = mchars_spec2cp(p->symtab, seq, sz);
 453                                 if (uc <= 0)
 454                                         break;
 455                                 encode1(p, uc);
 456                                 continue;
 457                         default:
 458                                 break;
 459                         }
 460
 461                 switch (esc) {
 462                 case (ESCAPE_UNICODE):
 463                         encode1(p, '?');
 464                         break;
 465                 case (ESCAPE_NUMBERED):
 466                         c = mchars_num2char(seq, sz);
 467                         if ('\0' != c)
 468                                 encode(p, &c, 1);
 469                         break;
 470                 case (ESCAPE_SPECIAL):
 471                         cp = mchars_spec2str(p->symtab, seq, sz, &ssz);
 472                         if (NULL != cp)
 473                                 encode(p, cp, ssz);
 474                         else if (1 == ssz)
 475                                 encode(p, seq, sz);
 476                         break;
 477                 case (ESCAPE_FONTBOLD):
 478                         term_fontrepl(p, TERMFONT_BOLD);
 479                         break;
 480                 case (ESCAPE_FONTITALIC):
 481                         term_fontrepl(p, TERMFONT_UNDER);
 482                         break;
 483                 case (ESCAPE_FONT):
 484                         /* FALLTHROUGH */
 485                 case (ESCAPE_FONTROMAN):
 486                         term_fontrepl(p, TERMFONT_NONE);
 487                         break;
 488                 case (ESCAPE_FONTPREV):
 489                         term_fontlast(p);
 490                         break;
 491                 case (ESCAPE_NOSPACE):
 492                         if (TERMP_SKIPCHAR & p->flags)
 493                                 p->flags &= ~TERMP_SKIPCHAR;
 494                         else if ('\0' == *word)
 495                                 p->flags |= TERMP_NOSPACE;
 496                         break;
 497                 case (ESCAPE_SKIPCHAR):
 498                         p->flags |= TERMP_SKIPCHAR;
 499                         break;
 500                 default:
 501                         break;
 502                 }
 503         }
 504 }
 505
 506 static void
 507 adjbuf(struct termp *p, int sz)
 508 {
 509
 510         if (0 == p->maxcols)
 511                 p->maxcols = 1024;
 512         while (sz >= p->maxcols)
 513                 p->maxcols <<= 2;
 514
 515         p->buf = mandoc_realloc
 516                 (p->buf, sizeof(int) * (size_t)p->maxcols);
 517 }
 518
 519 static void
 520 bufferc(struct termp *p, char c)
 521 {
 522
 523         if (p->col + 1 >= p->maxcols)
 524                 adjbuf(p, p->col + 1);
 525
 526         p->buf[p->col++] = c;
 527 }
 528
 529 /*
 530  * See encode().
 531  * Do this for a single (probably unicode) value.
 532  * Does not check for non-decorated glyphs.
 533  */
 534 static void
 535 encode1(struct termp *p, int c)
 536 {
 537         enum termfont     f;
 538
 539         if (TERMP_SKIPCHAR & p->flags) {
 540                 p->flags &= ~TERMP_SKIPCHAR;
 541                 return;
 542         }
 543
 544         if (p->col + 4 >= p->maxcols)
 545                 adjbuf(p, p->col + 4);
 546
 547         f = term_fonttop(p);
 548
 549         if (TERMFONT_NONE == f) {
 550                 p->buf[p->col++] = c;
 551                 return;
 552         } else if (TERMFONT_UNDER == f) {
 553                 p->buf[p->col++] = '_';
 554         } else
 555                 p->buf[p->col++] = c;
 556
 557         p->buf[p->col++] = 8;
 558         p->buf[p->col++] = c;
 559 }
 560
 561 static void
 562 encode(struct termp *p, const char *word, size_t sz)
 563 {
 564         enum termfont     f;
 565         int               i, len;
 566
 567         if (TERMP_SKIPCHAR & p->flags) {
 568                 p->flags &= ~TERMP_SKIPCHAR;
 569                 return;
 570         }
 571
 572         /* LINTED */
 573         len = sz;
 574
 575         /*
 576          * Encode and buffer a string of characters.  If the current
 577          * font mode is unset, buffer directly, else encode then buffer
 578          * character by character.
 579          */
 580
 581         if (TERMFONT_NONE == (f = term_fonttop(p))) {
 582                 if (p->col + len >= p->maxcols)
 583                         adjbuf(p, p->col + len);
 584                 for (i = 0; i < len; i++)
 585                         p->buf[p->col++] = word[i];
 586                 return;
 587         }
 588
 589         /* Pre-buffer, assuming worst-case. */
 590
 591         if (p->col + 1 + (len * 3) >= p->maxcols)
 592                 adjbuf(p, p->col + 1 + (len * 3));
 593
 594         for (i = 0; i < len; i++) {
 595                 if (ASCII_HYPH != word[i] &&
 596                     ! isgraph((unsigned char)word[i])) {
 597                         p->buf[p->col++] = word[i];
 598                         continue;
 599                 }
 600
 601                 if (TERMFONT_UNDER == f)
 602                         p->buf[p->col++] = '_';
 603                 else if (ASCII_HYPH == word[i])
 604                         p->buf[p->col++] = '-';
 605                 else
 606                         p->buf[p->col++] = word[i];
 607
 608                 p->buf[p->col++] = 8;
 609                 p->buf[p->col++] = word[i];
 610         }
 611 }
 612
 613 size_t
 614 term_len(const struct termp *p, size_t sz)
 615 {
 616
 617         return((*p->width)(p, ' ') * sz);
 618 }
 619
 620 static size_t
 621 cond_width(const struct termp *p, int c, int *skip)
 622 {
 623
 624         if (*skip) {
 625                 (*skip) = 0;
 626                 return(0);
 627         } else
 628                 return((*p->width)(p, c));
 629 }
 630
 631 size_t
 632 term_strlen(const struct termp *p, const char *cp)
 633 {
 634         size_t           sz, rsz, i;
 635         int              ssz, skip, c;
 636         const char      *seq, *rhs;
 637         enum mandoc_esc  esc;
 638         static const char rej[] = { '\\', ASCII_HYPH, ASCII_NBRSP, '\0' };
 639
 640         /*
 641          * Account for escaped sequences within string length
 642          * calculations.  This follows the logic in term_word() as we
 643          * must calculate the width of produced strings.
 644          */
 645
 646         sz = 0;
 647         skip = 0;
 648         while ('\0' != *cp) {
 649                 rsz = strcspn(cp, rej);
 650                 for (i = 0; i < rsz; i++)
 651                         sz += cond_width(p, *cp++, &skip);
 652
 653                 c = 0;
 654                 switch (*cp) {
 655                 case ('\\'):
 656                         cp++;
 657                         esc = mandoc_escape(&cp, &seq, &ssz);
 658                         if (ESCAPE_ERROR == esc)
 659                                 return(sz);
 660
 661                         if (TERMENC_ASCII != p->enc)
 662                                 switch (esc) {
 663                                 case (ESCAPE_UNICODE):
 664                                         c = mchars_num2uc
 665                                                 (seq + 1, ssz - 1);
 666                                         if ('\0' == c)
 667                                                 break;
 668                                         sz += cond_width(p, c, &skip);
 669                                         continue;
 670                                 case (ESCAPE_SPECIAL):
 671                                         c = mchars_spec2cp
 672                                                 (p->symtab, seq, ssz);
 673                                         if (c <= 0)
 674                                                 break;
 675                                         sz += cond_width(p, c, &skip);
 676                                         continue;
 677                                 default:
 678                                         break;
 679                                 }
 680
 681                         rhs = NULL;
 682
 683                         switch (esc) {
 684                         case (ESCAPE_UNICODE):
 685                                 sz += cond_width(p, '?', &skip);
 686                                 break;
 687                         case (ESCAPE_NUMBERED):
 688                                 c = mchars_num2char(seq, ssz);
 689                                 if ('\0' != c)
 690                                         sz += cond_width(p, c, &skip);
 691                                 break;
 692                         case (ESCAPE_SPECIAL):
 693                                 rhs = mchars_spec2str
 694                                         (p->symtab, seq, ssz, &rsz);
 695
 696                                 if (ssz != 1 || rhs)
 697                                         break;
 698
 699                                 rhs = seq;
 700                                 rsz = ssz;
 701                                 break;
 702                         case (ESCAPE_SKIPCHAR):
 703                                 skip = 1;
 704                                 break;
 705                         default:
 706                                 break;
 707                         }
 708
 709                         if (NULL == rhs)
 710                                 break;
 711
 712                         if (skip) {
 713                                 skip = 0;
 714                                 break;
 715                         }
 716
 717                         for (i = 0; i < rsz; i++)
 718                                 sz += (*p->width)(p, *rhs++);
 719                         break;
 720                 case (ASCII_NBRSP):
 721                         sz += cond_width(p, ' ', &skip);
 722                         cp++;
 723                         break;
 724                 case (ASCII_HYPH):
 725                         sz += cond_width(p, '-', &skip);
 726                         cp++;
 727                         break;
 728                 default:
 729                         break;
 730                 }
 731         }
 732
 733         return(sz);
 734 }
 735
 736 /* ARGSUSED */
 737 size_t
 738 term_vspan(const struct termp *p, const struct roffsu *su)
 739 {
 740         double           r;
 741
 742         switch (su->unit) {
 743         case (SCALE_CM):
 744                 r = su->scale * 2;
 745                 break;
 746         case (SCALE_IN):
 747                 r = su->scale * 6;
 748                 break;
 749         case (SCALE_PC):
 750                 r = su->scale;
 751                 break;
 752         case (SCALE_PT):
 753                 r = su->scale / 8;
 754                 break;
 755         case (SCALE_MM):
 756                 r = su->scale / 1000;
 757                 break;
 758         case (SCALE_VS):
 759                 r = su->scale;
 760                 break;
 761         default:
 762                 r = su->scale - 1;
 763                 break;
 764         }
 765
 766         if (r < 0.0)
 767                 r = 0.0;
 768         return(/* LINTED */(size_t)
 769                         r);
 770 }
 771
 772 size_t
 773 term_hspan(const struct termp *p, const struct roffsu *su)
 774 {
 775         double           v;
 776
 777         v = ((*p->hspan)(p, su));
 778         if (v < 0.0)
 779                 v = 0.0;
 780         return((size_t) /* LINTED */
 781                         v);
 782 }