term.c

   1 /*      $Id: term.c,v 1.132 2010/05/07 04:50:44 kristaps Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif
  20
  21 #include <sys/types.h>
  22
  23 #include <assert.h>
  24 #include <ctype.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <time.h>
  29
  30 #include "chars.h"
  31 #include "out.h"
  32 #include "term.h"
  33 #include "man.h"
  34 #include "mdoc.h"
  35 #include "main.h"
  36
  37 static  struct termp     *term_alloc(enum termenc);
  38 static  void              term_free(struct termp *);
  39 static  void              spec(struct termp *, const char *, size_t);
  40 static  void              res(struct termp *, const char *, size_t);
  41 static  void              buffera(struct termp *, const char *, size_t);
  42 static  void              bufferc(struct termp *, char);
  43 static  void              adjbuf(struct termp *p, size_t);
  44 static  void              encode(struct termp *, const char *, size_t);
  45
  46
  47 void *
  48 ascii_alloc(void)
  49 {
  50
  51         return(term_alloc(TERMENC_ASCII));
  52 }
  53
  54
  55 void
  56 terminal_free(void *arg)
  57 {
  58
  59         term_free((struct termp *)arg);
  60 }
  61
  62
  63 static void
  64 term_free(struct termp *p)
  65 {
  66
  67         if (p->buf)
  68                 free(p->buf);
  69         if (p->symtab)
  70                 chars_free(p->symtab);
  71
  72         free(p);
  73 }
  74
  75
  76 static struct termp *
  77 term_alloc(enum termenc enc)
  78 {
  79         struct termp *p;
  80
  81         p = calloc(1, sizeof(struct termp));
  82         if (NULL == p) {
  83                 perror(NULL);
  84                 exit(EXIT_FAILURE);
  85         }
  86         p->enc = enc;
  87         return(p);
  88 }
  89
  90
  91 /*
  92  * Flush a line of text.  A "line" is loosely defined as being something
  93  * that should be followed by a newline, regardless of whether it's
  94  * broken apart by newlines getting there.  A line can also be a
  95  * fragment of a columnar list (`Bl -tag' or `Bl -column'), which does
  96  * not have a trailing newline.
  97  *
  98  * The following flags may be specified:
  99  *
 100  *  - TERMP_NOLPAD: when beginning to write the line, don't left-pad the
 101  *    offset value.  This is useful when doing columnar lists where the
 102  *    prior column has right-padded.
 103  *
 104  *  - TERMP_NOBREAK: this is the most important and is used when making
 105  *    columns.  In short: don't print a newline and instead pad to the
 106  *    right margin.  Used in conjunction with TERMP_NOLPAD.
 107  *
 108  *  - TERMP_TWOSPACE: when padding, make sure there are at least two
 109  *    space characters of padding.  Otherwise, rather break the line.
 110  *
 111  *  - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and
 112  *    the line is overrun, and don't pad-right if it's underrun.
 113  *
 114  *  - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when
 115  *    overruning, instead save the position and continue at that point
 116  *    when the next invocation.
 117  *
 118  *  In-line line breaking:
 119  *
 120  *  If TERMP_NOBREAK is specified and the line overruns the right
 121  *  margin, it will break and pad-right to the right margin after
 122  *  writing.  If maxrmargin is violated, it will break and continue
 123  *  writing from the right-margin, which will lead to the above scenario
 124  *  upon exit.  Otherwise, the line will break at the right margin.
 125  */
 126 void
 127 term_flushln(struct termp *p)
 128 {
 129         int              i;     /* current input position in p->buf */
 130         size_t           vis;   /* current visual position on output */
 131         size_t           vbl;   /* number of blanks to prepend to output */
 132         size_t           vsz;   /* visual characters to write to output */
 133         size_t           bp;    /* visual right border position */
 134         int              j;     /* temporary loop index */
 135         size_t           maxvis, mmax;
 136
 137         /*
 138          * First, establish the maximum columns of "visible" content.
 139          * This is usually the difference between the right-margin and
 140          * an indentation, but can be, for tagged lists or columns, a
 141          * small set of values.
 142          */
 143
 144         assert(p->offset < p->rmargin);
 145
 146         maxvis = (int)(p->rmargin - p->offset) - p->overstep < 0 ?
 147                 /* LINTED */
 148                 0 : p->rmargin - p->offset - p->overstep;
 149         mmax = (int)(p->maxrmargin - p->offset) - p->overstep < 0 ?
 150                 /* LINTED */
 151                 0 : p->maxrmargin - p->offset - p->overstep;
 152
 153         bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
 154
 155         /*
 156          * FIXME: if bp is zero, we still output the first word before
 157          * breaking the line.
 158          */
 159
 160         vis = 0;
 161
 162         /*
 163          * If in the standard case (left-justified), then begin with our
 164          * indentation, otherwise (columns, etc.) just start spitting
 165          * out text.
 166          */
 167
 168         if ( ! (p->flags & TERMP_NOLPAD))
 169                 /* LINTED */
 170                 for (j = 0; j < (int)p->offset; j++)
 171                         putchar(' ');
 172
 173         for (i = 0; i < (int)p->col; i++) {
 174                 /*
 175                  * Count up visible word characters.  Control sequences
 176                  * (starting with the CSI) aren't counted.  A space
 177                  * generates a non-printing word, which is valid (the
 178                  * space is printed according to regular spacing rules).
 179                  */
 180
 181                 /* LINTED */
 182                 for (j = i, vsz = 0; j < (int)p->col; j++) {
 183                         if (j && ' ' == p->buf[j])
 184                                 break;
 185                         if (8 == p->buf[j])
 186                                 vsz--;
 187                         else
 188                                 vsz++;
 189                 }
 190
 191                 /*
 192                  * Choose the number of blanks to prepend: no blank at the
 193                  * beginning of a line, one between words -- but do not
 194                  * actually write them yet.
 195                  */
 196
 197                 vbl = (size_t)(0 == vis ? 0 : 1);
 198
 199                 /*
 200                  * Find out whether we would exceed the right margin.
 201                  * If so, break to the next line.  Otherwise, write the chosen
 202                  * number of blanks.
 203                  */
 204
 205                 if (vis && vis + vbl + vsz > bp) {
 206                         putchar('\n');
 207                         if (TERMP_NOBREAK & p->flags) {
 208                                 for (j = 0; j < (int)p->rmargin; j++)
 209                                         putchar(' ');
 210                                 vis = p->rmargin - p->offset;
 211                         } else {
 212                                 for (j = 0; j < (int)p->offset; j++)
 213                                         putchar(' ');
 214                                 vis = 0;
 215                         }
 216
 217                         /* Remove the p->overstep width. */
 218
 219                         bp += (int)/* LINTED */
 220                                 p->overstep;
 221                         p->overstep = 0;
 222                 } else {
 223                         for (j = 0; j < (int)vbl; j++)
 224                                 putchar(' ');
 225                         vis += vbl;
 226                 }
 227
 228                 /* Write out the [remaining] word. */
 229                 for ( ; i < (int)p->col; i++)
 230                         if (' ' == p->buf[i])
 231                                 break;
 232                         else if (31 == p->buf[i])
 233                                 putchar(' ');
 234                         else
 235                                 putchar(p->buf[i]);
 236
 237                 vis += vsz;
 238         }
 239
 240         p->col = 0;
 241         p->overstep = 0;
 242
 243         if ( ! (TERMP_NOBREAK & p->flags)) {
 244                 putchar('\n');
 245                 return;
 246         }
 247
 248         if (TERMP_HANG & p->flags) {
 249                 /* We need one blank after the tag. */
 250                 p->overstep = /* LINTED */
 251                         vis - maxvis + 1;
 252
 253                 /*
 254                  * Behave exactly the same way as groff:
 255                  * If we have overstepped the margin, temporarily move
 256                  * it to the right and flag the rest of the line to be
 257                  * shorter.
 258                  * If we landed right at the margin, be happy.
 259                  * If we are one step before the margin, temporarily
 260                  * move it one step LEFT and flag the rest of the line
 261                  * to be longer.
 262                  */
 263                 if (p->overstep >= -1) {
 264                         assert((int)maxvis + p->overstep >= 0);
 265                         /* LINTED */
 266                         maxvis += p->overstep;
 267                 } else
 268                         p->overstep = 0;
 269
 270         } else if (TERMP_DANGLE & p->flags)
 271                 return;
 272
 273         /* Right-pad. */
 274         if (maxvis > vis + /* LINTED */
 275                         ((TERMP_TWOSPACE & p->flags) ? 1 : 0))
 276                 for ( ; vis < maxvis; vis++)
 277                         putchar(' ');
 278         else {  /* ...or newline break. */
 279                 putchar('\n');
 280                 for (i = 0; i < (int)p->rmargin; i++)
 281                         putchar(' ');
 282         }
 283 }
 284
 285
 286 /*
 287  * A newline only breaks an existing line; it won't assert vertical
 288  * space.  All data in the output buffer is flushed prior to the newline
 289  * assertion.
 290  */
 291 void
 292 term_newln(struct termp *p)
 293 {
 294
 295         p->flags |= TERMP_NOSPACE;
 296         if (0 == p->col) {
 297                 p->flags &= ~TERMP_NOLPAD;
 298                 return;
 299         }
 300         term_flushln(p);
 301         p->flags &= ~TERMP_NOLPAD;
 302 }
 303
 304
 305 /*
 306  * Asserts a vertical space (a full, empty line-break between lines).
 307  * Note that if used twice, this will cause two blank spaces and so on.
 308  * All data in the output buffer is flushed prior to the newline
 309  * assertion.
 310  */
 311 void
 312 term_vspace(struct termp *p)
 313 {
 314
 315         term_newln(p);
 316         putchar('\n');
 317 }
 318
 319
 320 static void
 321 spec(struct termp *p, const char *word, size_t len)
 322 {
 323         const char      *rhs;
 324         size_t           sz;
 325
 326         rhs = chars_a2ascii(p->symtab, word, len, &sz);
 327         if (rhs)
 328                 encode(p, rhs, sz);
 329 }
 330
 331
 332 static void
 333 res(struct termp *p, const char *word, size_t len)
 334 {
 335         const char      *rhs;
 336         size_t           sz;
 337
 338         rhs = chars_a2res(p->symtab, word, len, &sz);
 339         if (rhs)
 340                 encode(p, rhs, sz);
 341 }
 342
 343
 344 void
 345 term_fontlast(struct termp *p)
 346 {
 347         enum termfont    f;
 348
 349         f = p->fontl;
 350         p->fontl = p->fontq[p->fonti];
 351         p->fontq[p->fonti] = f;
 352 }
 353
 354
 355 void
 356 term_fontrepl(struct termp *p, enum termfont f)
 357 {
 358
 359         p->fontl = p->fontq[p->fonti];
 360         p->fontq[p->fonti] = f;
 361 }
 362
 363
 364 void
 365 term_fontpush(struct termp *p, enum termfont f)
 366 {
 367
 368         assert(p->fonti + 1 < 10);
 369         p->fontl = p->fontq[p->fonti];
 370         p->fontq[++p->fonti] = f;
 371 }
 372
 373
 374 const void *
 375 term_fontq(struct termp *p)
 376 {
 377
 378         return(&p->fontq[p->fonti]);
 379 }
 380
 381
 382 enum termfont
 383 term_fonttop(struct termp *p)
 384 {
 385
 386         return(p->fontq[p->fonti]);
 387 }
 388
 389
 390 void
 391 term_fontpopq(struct termp *p, const void *key)
 392 {
 393
 394         while (p->fonti >= 0 && key != &p->fontq[p->fonti])
 395                 p->fonti--;
 396         assert(p->fonti >= 0);
 397 }
 398
 399
 400 void
 401 term_fontpop(struct termp *p)
 402 {
 403
 404         assert(p->fonti);
 405         p->fonti--;
 406 }
 407
 408
 409 /*
 410  * Handle pwords, partial words, which may be either a single word or a
 411  * phrase that cannot be broken down (such as a literal string).  This
 412  * handles word styling.
 413  */
 414 void
 415 term_word(struct termp *p, const char *word)
 416 {
 417         const char      *sv, *seq;
 418         int              sz;
 419         size_t           ssz;
 420         enum roffdeco    deco;
 421
 422         sv = word;
 423
 424         if (word[0] && '\0' == word[1])
 425                 switch (word[0]) {
 426                 case('.'):
 427                         /* FALLTHROUGH */
 428                 case(','):
 429                         /* FALLTHROUGH */
 430                 case(';'):
 431                         /* FALLTHROUGH */
 432                 case(':'):
 433                         /* FALLTHROUGH */
 434                 case('?'):
 435                         /* FALLTHROUGH */
 436                 case('!'):
 437                         /* FALLTHROUGH */
 438                 case(')'):
 439                         /* FALLTHROUGH */
 440                 case(']'):
 441                         if ( ! (TERMP_IGNDELIM & p->flags))
 442                                 p->flags |= TERMP_NOSPACE;
 443                         break;
 444                 default:
 445                         break;
 446                 }
 447
 448         if ( ! (TERMP_NOSPACE & p->flags))
 449                 bufferc(p, ' ');
 450
 451         if ( ! (p->flags & TERMP_NONOSPACE))
 452                 p->flags &= ~TERMP_NOSPACE;
 453
 454         /* FIXME: use strcspn. */
 455
 456         while (*word) {
 457                 if ('\\' != *word) {
 458                         encode(p, word, 1);
 459                         word++;
 460                         continue;
 461                 }
 462
 463                 seq = ++word;
 464                 sz = a2roffdeco(&deco, &seq, &ssz);
 465
 466                 switch (deco) {
 467                 case (DECO_RESERVED):
 468                         res(p, seq, ssz);
 469                         break;
 470                 case (DECO_SPECIAL):
 471                         spec(p, seq, ssz);
 472                         break;
 473                 case (DECO_BOLD):
 474                         term_fontrepl(p, TERMFONT_BOLD);
 475                         break;
 476                 case (DECO_ITALIC):
 477                         term_fontrepl(p, TERMFONT_UNDER);
 478                         break;
 479                 case (DECO_ROMAN):
 480                         term_fontrepl(p, TERMFONT_NONE);
 481                         break;
 482                 case (DECO_PREVIOUS):
 483                         term_fontlast(p);
 484                         break;
 485                 default:
 486                         break;
 487                 }
 488
 489                 word += sz;
 490                 if (DECO_NOSPACE == deco && '\0' == *word)
 491                         p->flags |= TERMP_NOSPACE;
 492         }
 493
 494         /*
 495          * Note that we don't process the pipe: the parser sees it as
 496          * punctuation, but we don't in terms of typography.
 497          */
 498         if (sv[0] && 0 == sv[1])
 499                 switch (sv[0]) {
 500                 case('('):
 501                         /* FALLTHROUGH */
 502                 case('['):
 503                         p->flags |= TERMP_NOSPACE;
 504                         break;
 505                 default:
 506                         break;
 507                 }
 508 }
 509
 510
 511 static void
 512 adjbuf(struct termp *p, size_t sz)
 513 {
 514
 515         if (0 == p->maxcols)
 516                 p->maxcols = 1024;
 517         while (sz >= p->maxcols)
 518                 p->maxcols <<= 2;
 519
 520         p->buf = realloc(p->buf, p->maxcols);
 521         if (NULL == p->buf) {
 522                 perror(NULL);
 523                 exit(EXIT_FAILURE);
 524         }
 525 }
 526
 527
 528 static void
 529 buffera(struct termp *p, const char *word, size_t sz)
 530 {
 531
 532         if (p->col + sz >= p->maxcols)
 533                 adjbuf(p, p->col + sz);
 534
 535         memcpy(&p->buf[(int)p->col], word, sz);
 536         p->col += sz;
 537 }
 538
 539
 540 static void
 541 bufferc(struct termp *p, char c)
 542 {
 543
 544         if (p->col + 1 >= p->maxcols)
 545                 adjbuf(p, p->col + 1);
 546
 547         p->buf[(int)p->col++] = c;
 548 }
 549
 550
 551 static void
 552 encode(struct termp *p, const char *word, size_t sz)
 553 {
 554         enum termfont     f;
 555         int               i;
 556
 557         /*
 558          * Encode and buffer a string of characters.  If the current
 559          * font mode is unset, buffer directly, else encode then buffer
 560          * character by character.
 561          */
 562
 563         if (TERMFONT_NONE == (f = term_fonttop(p))) {
 564                 buffera(p, word, sz);
 565                 return;
 566         }
 567
 568         for (i = 0; i < (int)sz; i++) {
 569                 if ( ! isgraph((u_char)word[i])) {
 570                         bufferc(p, word[i]);
 571                         continue;
 572                 }
 573
 574                 if (TERMFONT_UNDER == f)
 575                         bufferc(p, '_');
 576                 else
 577                         bufferc(p, word[i]);
 578
 579                 bufferc(p, 8);
 580                 bufferc(p, word[i]);
 581         }
 582 }
 583
 584
 585 size_t
 586 term_vspan(const struct roffsu *su)
 587 {
 588         double           r;
 589
 590         switch (su->unit) {
 591         case (SCALE_CM):
 592                 r = su->scale * 2;
 593                 break;
 594         case (SCALE_IN):
 595                 r = su->scale * 6;
 596                 break;
 597         case (SCALE_PC):
 598                 r = su->scale;
 599                 break;
 600         case (SCALE_PT):
 601                 r = su->scale / 8;
 602                 break;
 603         case (SCALE_MM):
 604                 r = su->scale / 1000;
 605                 break;
 606         case (SCALE_VS):
 607                 r = su->scale;
 608                 break;
 609         default:
 610                 r = su->scale - 1;
 611                 break;
 612         }
 613
 614         if (r < 0.0)
 615                 r = 0.0;
 616         return(/* LINTED */(size_t)
 617                         r);
 618 }
 619
 620
 621 size_t
 622 term_hspan(const struct roffsu *su)
 623 {
 624         double           r;
 625
 626         /* XXX: CM, IN, and PT are approximations. */
 627
 628         switch (su->unit) {
 629         case (SCALE_CM):
 630                 r = 4 * su->scale;
 631                 break;
 632         case (SCALE_IN):
 633                 /* XXX: this is an approximation. */
 634                 r = 10 * su->scale;
 635                 break;
 636         case (SCALE_PC):
 637                 r = (10 * su->scale) / 6;
 638                 break;
 639         case (SCALE_PT):
 640                 r = (10 * su->scale) / 72;
 641                 break;
 642         case (SCALE_MM):
 643                 r = su->scale / 1000; /* FIXME: double-check. */
 644                 break;
 645         case (SCALE_VS):
 646                 r = su->scale * 2 - 1; /* FIXME: double-check. */
 647                 break;
 648         default:
 649                 r = su->scale;
 650                 break;
 651         }
 652
 653         if (r < 0.0)
 654                 r = 0.0;
 655         return((size_t)/* LINTED */
 656                         r);
 657 }
 658
 659