term.c

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