1 /* $Id: term.c,v 1.281 2019/06/03 20:23:41 schwarze Exp $ */
3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010-2019 Ingo Schwarze <schwarze@openbsd.org>
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.
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.
20 #include <sys/types.h>
30 #include "mandoc_aux.h"
35 static size_t cond_width(const struct termp *, int, int *);
36 static void adjbuf(struct termp_col *, size_t);
37 static void bufferc(struct termp *, char);
38 static void encode(struct termp *, const char *, size_t);
39 static void encode1(struct termp *, int);
40 static void endline(struct termp *);
41 static void term_field(struct termp *, size_t, size_t,
43 static void term_fill(struct termp *, size_t *, size_t *,
48 term_setcol(struct termp *p, size_t maxtcol)
50 if (maxtcol > p->maxtcol) {
51 p->tcols = mandoc_recallocarray(p->tcols,
52 p->maxtcol, maxtcol, sizeof(*p->tcols));
55 p->lasttcol = maxtcol - 1;
60 term_free(struct termp *p)
62 for (p->tcol = p->tcols; p->tcol < p->tcols + p->maxtcol; p->tcol++)
70 term_begin(struct termp *p, term_margin head,
71 term_margin foot, const struct roff_meta *arg)
81 term_end(struct termp *p)
88 * Flush a chunk of text. By default, break the output line each time
89 * the right margin is reached, and continue output on the next line
90 * at the same offset as the chunk itself. By default, also break the
91 * output line at the end of the chunk. There are many flags modifying
92 * this behaviour, see the comments in the body of the function.
95 term_flushln(struct termp *p)
97 size_t vbl; /* Number of blanks to prepend to the output. */
98 size_t vbr; /* Actual visual position of the end of field. */
99 size_t vfield; /* Desired visual field width. */
100 size_t vtarget; /* Desired visual position of the right margin. */
101 size_t ic; /* Character position in the input buffer. */
102 size_t nbr; /* Number of characters to print in this field. */
105 * Normally, start writing at the left margin, but with the
106 * NOPAD flag, start writing at the current position instead.
109 vbl = (p->flags & TERMP_NOPAD) || p->tcol->offset < p->viscol ?
110 0 : p->tcol->offset - p->viscol;
111 if (p->minbl && vbl < p->minbl)
114 if ((p->flags & TERMP_MULTICOL) == 0)
117 /* Loop over output lines. */
120 vfield = p->tcol->rmargin > p->viscol + vbl ?
121 p->tcol->rmargin - p->viscol - vbl : 0;
124 * Normally, break the line at the the right margin
125 * of the field, but with the NOBREAK flag, only
126 * break it at the max right margin of the screen,
127 * and with the BRNEVER flag, never break it at all.
130 vtarget = p->flags & TERMP_BRNEVER ? SIZE_MAX :
131 (p->flags & TERMP_NOBREAK) == 0 ? vfield :
132 p->maxrmargin > p->viscol + vbl ?
133 p->maxrmargin - p->viscol - vbl : 0;
136 * Figure out how much text will fit in the field.
137 * If there is whitespace only, print nothing.
140 term_fill(p, &nbr, &vbr, vtarget);
145 * With the CENTER or RIGHT flag, increase the indentation
146 * to center the text between the left and right margins
147 * or to adjust it to the right margin, respectively.
151 if (p->flags & TERMP_CENTER)
152 vbl += (vtarget - vbr) / 2;
153 else if (p->flags & TERMP_RIGHT)
154 vbl += vtarget - vbr;
157 /* Finally, print the field content. */
159 term_field(p, vbl, nbr, vbr, vtarget);
162 * If there is no text left in the field, exit the loop.
163 * If the BRTRSP flag is set, consider trailing
164 * whitespace significant when deciding whether
165 * the field fits or not.
168 for (ic = p->tcol->col; ic < p->tcol->lastcol; ic++) {
169 switch (p->tcol->buf[ic]) {
171 if (p->flags & TERMP_BRTRSP)
172 vbr = term_tab_next(vbr);
175 if (p->flags & TERMP_BRTRSP)
176 vbr += (*p->width)(p, ' ');
186 if (ic == p->tcol->lastcol)
190 * At the location of an automtic line break, input
191 * space characters are consumed by the line break.
194 while (p->tcol->col < p->tcol->lastcol &&
195 p->tcol->buf[p->tcol->col] == ' ')
199 * In multi-column mode, leave the rest of the text
200 * in the buffer to be handled by a subsequent
201 * invocation, such that the other columns of the
202 * table can be handled first.
203 * In single-column mode, simply break the line.
206 if (p->flags & TERMP_MULTICOL)
213 * Normally, start the next line at the same indentation
214 * as this one, but with the BRIND flag, start it at the
215 * right margin instead. This is used together with
216 * NOBREAK for the tags in various kinds of tagged lists.
219 vbl = p->flags & TERMP_BRIND ?
220 p->tcol->rmargin : p->tcol->offset;
223 /* Reset output state in preparation for the next field. */
225 p->col = p->tcol->col = p->tcol->lastcol = 0;
226 p->minbl = p->trailspace;
227 p->flags &= ~(TERMP_BACKAFTER | TERMP_BACKBEFORE | TERMP_NOPAD);
229 if (p->flags & TERMP_MULTICOL)
233 * The HANG flag means that the next field
234 * always follows on the same line.
235 * The NOBREAK flag means that the next field
236 * follows on the same line unless the field was overrun.
237 * Normally, break the line at the end of each field.
240 if ((p->flags & TERMP_HANG) == 0 &&
241 ((p->flags & TERMP_NOBREAK) == 0 ||
242 vbr + term_len(p, p->trailspace) > vfield))
247 * Store the number of input characters to print in this field in *nbr
248 * and their total visual width to print in *vbr.
249 * If there is only whitespace in the field, both remain zero.
250 * The desired visual width of the field is provided by vtarget.
251 * If the first word is longer, the field will be overrun.
254 term_fill(struct termp *p, size_t *nbr, size_t *vbr, size_t vtarget)
256 size_t ic; /* Character position in the input buffer. */
257 size_t vis; /* Visual position of the current character. */
258 size_t vn; /* Visual position of the next character. */
259 int breakline; /* Break at the end of this word. */
260 int graph; /* Last character was non-blank. */
262 *nbr = *vbr = vis = 0;
263 breakline = graph = 0;
264 for (ic = p->tcol->col; ic < p->tcol->lastcol; ic++) {
265 switch (p->tcol->buf[ic]) {
266 case '\b': /* Escape \o (overstrike) or backspace markup. */
268 vis -= (*p->width)(p, p->tcol->buf[ic - 1]);
271 case '\t': /* Normal ASCII whitespace. */
273 case ASCII_BREAK: /* Escape \: (breakpoint). */
274 switch (p->tcol->buf[ic]) {
276 vn = term_tab_next(vis);
279 vn = vis + (*p->width)(p, ' ');
287 /* Can break at the end of a word. */
288 if (breakline || vn > vtarget)
298 case '\n': /* Escape \p (break at the end of the word). */
302 case ASCII_HYPH: /* Breakable hyphen. */
305 * We are about to decide whether to break the
306 * line or not, so we no longer need this hyphen
307 * to be marked as breakable. Put back a real
308 * hyphen such that we get the correct width.
310 p->tcol->buf[ic] = '-';
311 vis += (*p->width)(p, '-');
320 case ASCII_NBRSP: /* Non-breakable space. */
321 p->tcol->buf[ic] = ' ';
323 default: /* Printable character. */
325 vis += (*p->width)(p, p->tcol->buf[ic]);
326 if (vis > vtarget && *nbr > 0)
334 * If the last word extends to the end of the field without any
335 * trailing whitespace, the loop could not check yet whether it
336 * can remain on this line. So do the check now.
339 if (graph && (vis <= vtarget || *nbr == 0)) {
346 * Print the contents of one field
347 * with an indentation of vbl visual columns,
348 * an input string length of nbr characters,
349 * an output width of vbr visual columns,
350 * and a desired field width of vtarget visual columns.
353 term_field(struct termp *p, size_t vbl, size_t nbr, size_t vbr, size_t vtarget)
355 size_t ic; /* Character position in the input buffer. */
356 size_t vis; /* Visual position of the current character. */
357 size_t dv; /* Visual width of the current character. */
358 size_t vn; /* Visual position of the next character. */
361 for (ic = p->tcol->col; ic < nbr; ic++) {
364 * To avoid the printing of trailing whitespace,
365 * do not print whitespace right away, only count it.
368 switch (p->tcol->buf[ic]) {
373 vn = term_tab_next(vis);
379 dv = (*p->width)(p, ' ');
388 * We found a non-blank character to print,
389 * so write preceding white space now.
393 (*p->advance)(p, vbl);
398 /* Print the character and adjust the visual position. */
400 (*p->letter)(p, p->tcol->buf[ic]);
401 if (p->tcol->buf[ic] == '\b') {
402 dv = (*p->width)(p, p->tcol->buf[ic - 1]);
406 dv = (*p->width)(p, p->tcol->buf[ic]);
415 endline(struct termp *p)
417 if ((p->flags & (TERMP_NEWMC | TERMP_ENDMC)) == TERMP_ENDMC) {
419 p->flags &= ~TERMP_ENDMC;
422 if (p->viscol && p->maxrmargin >= p->viscol)
423 (*p->advance)(p, p->maxrmargin - p->viscol + 1);
424 p->flags |= TERMP_NOBUF | TERMP_NOSPACE;
426 p->flags &= ~(TERMP_NOBUF | TERMP_NEWMC);
434 * A newline only breaks an existing line; it won't assert vertical
435 * space. All data in the output buffer is flushed prior to the newline
439 term_newln(struct termp *p)
442 p->flags |= TERMP_NOSPACE;
443 if (p->tcol->lastcol || p->viscol)
448 * Asserts a vertical space (a full, empty line-break between lines).
449 * Note that if used twice, this will cause two blank spaces and so on.
450 * All data in the output buffer is flushed prior to the newline
454 term_vspace(struct termp *p)
466 /* Swap current and previous font; for \fP and .ft P */
468 term_fontlast(struct termp *p)
473 p->fontl = p->fontq[p->fonti];
474 p->fontq[p->fonti] = f;
477 /* Set font, save current, discard previous; for \f, .ft, .B etc. */
479 term_fontrepl(struct termp *p, enum termfont f)
482 p->fontl = p->fontq[p->fonti];
483 p->fontq[p->fonti] = f;
486 /* Set font, save previous. */
488 term_fontpush(struct termp *p, enum termfont f)
491 p->fontl = p->fontq[p->fonti];
492 if (++p->fonti == p->fontsz) {
494 p->fontq = mandoc_reallocarray(p->fontq,
495 p->fontsz, sizeof(*p->fontq));
497 p->fontq[p->fonti] = f;
500 /* Flush to make the saved pointer current again. */
502 term_fontpopq(struct termp *p, int i)
510 /* Pop one font off the stack. */
512 term_fontpop(struct termp *p)
520 * Handle pwords, partial words, which may be either a single word or a
521 * phrase that cannot be broken down (such as a literal string). This
522 * handles word styling.
525 term_word(struct termp *p, const char *word)
528 const char nbrsp[2] = { ASCII_NBRSP, 0 };
529 const char *seq, *cp;
531 size_t csz, lsz, ssz;
534 if ((p->flags & TERMP_NOBUF) == 0) {
535 if ((p->flags & TERMP_NOSPACE) == 0) {
536 if ((p->flags & TERMP_KEEP) == 0) {
538 if (p->flags & TERMP_SENTENCE)
541 bufferc(p, ASCII_NBRSP);
543 if (p->flags & TERMP_PREKEEP)
544 p->flags |= TERMP_KEEP;
545 if (p->flags & TERMP_NONOSPACE)
546 p->flags |= TERMP_NOSPACE;
548 p->flags &= ~TERMP_NOSPACE;
549 p->flags &= ~(TERMP_SENTENCE | TERMP_NONEWLINE);
553 while ('\0' != *word) {
555 if (TERMP_NBRWORD & p->flags) {
561 ssz = strcspn(word, "\\ ");
563 ssz = strcspn(word, "\\");
564 encode(p, word, ssz);
570 esc = mandoc_escape(&word, &seq, &sz);
573 uc = mchars_num2uc(seq + 1, sz - 1);
575 case ESCAPE_NUMBERED:
576 uc = mchars_num2char(seq, sz);
581 if (p->enc == TERMENC_ASCII) {
582 cp = mchars_spec2str(seq, sz, &ssz);
586 uc = mchars_spec2cp(seq, sz);
594 case ESCAPE_FONTBOLD:
595 term_fontrepl(p, TERMFONT_BOLD);
597 case ESCAPE_FONTITALIC:
598 term_fontrepl(p, TERMFONT_UNDER);
601 term_fontrepl(p, TERMFONT_BI);
605 case ESCAPE_FONTROMAN:
606 term_fontrepl(p, TERMFONT_NONE);
608 case ESCAPE_FONTPREV:
615 if (p->flags & TERMP_BACKAFTER)
616 p->flags &= ~TERMP_BACKAFTER;
617 else if (*word == '\0')
618 p->flags |= (TERMP_NOSPACE | TERMP_NONEWLINE);
621 if (p->type == TERMTYPE_PDF)
623 else if (p->type == TERMTYPE_PS)
625 else if (p->enc == TERMENC_ASCII)
626 encode(p, "ascii", 5);
628 encode(p, "utf8", 4);
636 if (a2roffsu(seq, &su, SCALE_EM) == NULL)
638 uc += term_hen(p, &su);
641 bufferc(p, ASCII_NBRSP);
642 else if (p->col > (size_t)(-uc))
647 if (p->tcol->offset > (size_t)(-uc)) {
649 p->tcol->offset += uc;
651 p->ti -= p->tcol->offset;
657 if ((cp = a2roffsu(seq, &su, SCALE_EM)) == NULL)
659 uc = term_hen(p, &su);
661 if (p->tcol->rmargin <= p->tcol->offset)
663 lsz = p->tcol->rmargin - p->tcol->offset;
668 else if (*cp == '\\') {
670 esc = mandoc_escape(&seq, &cp, &sz);
673 uc = mchars_num2uc(cp + 1, sz - 1);
675 case ESCAPE_NUMBERED:
676 uc = mchars_num2char(cp, sz);
679 uc = mchars_spec2cp(cp, sz);
690 if (uc < 0x20 || (uc > 0x7E && uc < 0xA0))
692 if (p->enc == TERMENC_ASCII) {
693 cp = ascii_uc2str(uc);
694 csz = term_strlen(p, cp);
697 csz = (*p->width)(p, uc);
699 if (p->enc == TERMENC_ASCII)
706 case ESCAPE_SKIPCHAR:
707 p->flags |= TERMP_BACKAFTER;
709 case ESCAPE_OVERSTRIKE:
713 mandoc_escape(&seq, NULL, NULL);
718 if (p->flags & TERMP_BACKBEFORE)
719 p->flags |= TERMP_BACKAFTER;
721 p->flags |= TERMP_BACKBEFORE;
724 /* Trim trailing backspace/blank pair. */
725 if (p->tcol->lastcol > 2 &&
726 (p->tcol->buf[p->tcol->lastcol - 1] == ' ' ||
727 p->tcol->buf[p->tcol->lastcol - 1] == '\t'))
728 p->tcol->lastcol -= 2;
729 if (p->col > p->tcol->lastcol)
730 p->col = p->tcol->lastcol;
737 * Common handling for Unicode and numbered
738 * character escape sequences.
741 if (p->enc == TERMENC_ASCII) {
742 cp = ascii_uc2str(uc);
743 encode(p, cp, strlen(cp));
745 if ((uc < 0x20 && uc != 0x09) ||
746 (uc > 0x7E && uc < 0xA0))
751 p->flags &= ~TERMP_NBRWORD;
755 adjbuf(struct termp_col *c, size_t sz)
759 while (c->maxcols <= sz)
761 c->buf = mandoc_reallocarray(c->buf, c->maxcols, sizeof(*c->buf));
765 bufferc(struct termp *p, char c)
767 if (p->flags & TERMP_NOBUF) {
771 if (p->col + 1 >= p->tcol->maxcols)
772 adjbuf(p->tcol, p->col + 1);
773 if (p->tcol->lastcol <= p->col || (c != ' ' && c != ASCII_NBRSP))
774 p->tcol->buf[p->col] = c;
775 if (p->tcol->lastcol < ++p->col)
776 p->tcol->lastcol = p->col;
781 * Do this for a single (probably unicode) value.
782 * Does not check for non-decorated glyphs.
785 encode1(struct termp *p, int c)
789 if (p->flags & TERMP_NOBUF) {
794 if (p->col + 7 >= p->tcol->maxcols)
795 adjbuf(p->tcol, p->col + 7);
797 f = (c == ASCII_HYPH || c > 127 || isgraph(c)) ?
798 p->fontq[p->fonti] : TERMFONT_NONE;
800 if (p->flags & TERMP_BACKBEFORE) {
801 if (p->tcol->buf[p->col - 1] == ' ' ||
802 p->tcol->buf[p->col - 1] == '\t')
805 p->tcol->buf[p->col++] = '\b';
806 p->flags &= ~TERMP_BACKBEFORE;
808 if (f == TERMFONT_UNDER || f == TERMFONT_BI) {
809 p->tcol->buf[p->col++] = '_';
810 p->tcol->buf[p->col++] = '\b';
812 if (f == TERMFONT_BOLD || f == TERMFONT_BI) {
814 p->tcol->buf[p->col++] = '-';
816 p->tcol->buf[p->col++] = c;
817 p->tcol->buf[p->col++] = '\b';
819 if (p->tcol->lastcol <= p->col || (c != ' ' && c != ASCII_NBRSP))
820 p->tcol->buf[p->col] = c;
821 if (p->tcol->lastcol < ++p->col)
822 p->tcol->lastcol = p->col;
823 if (p->flags & TERMP_BACKAFTER) {
824 p->flags |= TERMP_BACKBEFORE;
825 p->flags &= ~TERMP_BACKAFTER;
830 encode(struct termp *p, const char *word, size_t sz)
834 if (p->flags & TERMP_NOBUF) {
835 for (i = 0; i < sz; i++)
836 (*p->letter)(p, word[i]);
840 if (p->col + 2 + (sz * 5) >= p->tcol->maxcols)
841 adjbuf(p->tcol, p->col + 2 + (sz * 5));
843 for (i = 0; i < sz; i++) {
844 if (ASCII_HYPH == word[i] ||
845 isgraph((unsigned char)word[i]))
848 if (p->tcol->lastcol <= p->col ||
849 (word[i] != ' ' && word[i] != ASCII_NBRSP))
850 p->tcol->buf[p->col] = word[i];
854 * Postpone the effect of \z while handling
855 * an overstrike sequence from ascii_uc2str().
858 if (word[i] == '\b' &&
859 (p->flags & TERMP_BACKBEFORE)) {
860 p->flags &= ~TERMP_BACKBEFORE;
861 p->flags |= TERMP_BACKAFTER;
865 if (p->tcol->lastcol < p->col)
866 p->tcol->lastcol = p->col;
870 term_setwidth(struct termp *p, const char *wstr)
890 if (a2roffsu(wstr, &su, SCALE_MAX) != NULL)
891 width = term_hspan(p, &su);
895 (*p->setwidth)(p, iop, width);
899 term_len(const struct termp *p, size_t sz)
902 return (*p->width)(p, ' ') * sz;
906 cond_width(const struct termp *p, int c, int *skip)
913 return (*p->width)(p, c);
917 term_strlen(const struct termp *p, const char *cp)
921 const char *seq, *rhs;
923 static const char rej[] = { '\\', ASCII_NBRSP, ASCII_HYPH,
927 * Account for escaped sequences within string length
928 * calculations. This follows the logic in term_word() as we
929 * must calculate the width of produced strings.
934 while ('\0' != *cp) {
935 rsz = strcspn(cp, rej);
936 for (i = 0; i < rsz; i++)
937 sz += cond_width(p, *cp++, &skip);
943 esc = mandoc_escape(&cp, &seq, &ssz);
946 uc = mchars_num2uc(seq + 1, ssz - 1);
948 case ESCAPE_NUMBERED:
949 uc = mchars_num2char(seq, ssz);
954 if (p->enc == TERMENC_ASCII) {
955 rhs = mchars_spec2str(seq, ssz, &rsz);
959 uc = mchars_spec2cp(seq, ssz);
961 sz += cond_width(p, uc, &skip);
968 if (p->type == TERMTYPE_PDF) {
971 } else if (p->type == TERMTYPE_PS) {
974 } else if (p->enc == TERMENC_ASCII) {
982 case ESCAPE_SKIPCHAR:
985 case ESCAPE_OVERSTRIKE:
990 mandoc_escape(&seq, NULL, NULL);
993 i = (*p->width)(p, *seq++);
1004 * Common handling for Unicode and numbered
1005 * character escape sequences.
1009 if (p->enc == TERMENC_ASCII) {
1010 rhs = ascii_uc2str(uc);
1013 if ((uc < 0x20 && uc != 0x09) ||
1014 (uc > 0x7E && uc < 0xA0))
1016 sz += cond_width(p, uc, &skip);
1027 * Common handling for all escape sequences
1028 * printing more than one character.
1031 for (i = 0; i < rsz; i++)
1032 sz += (*p->width)(p, *rhs++);
1035 sz += cond_width(p, ' ', &skip);
1039 sz += cond_width(p, '-', &skip);
1051 term_vspan(const struct termp *p, const struct roffsu *su)
1058 r = su->scale / 40.0;
1061 r = su->scale * 6.0 / 2.54;
1064 r = su->scale * 65536.0 / 40.0;
1067 r = su->scale * 6.0;
1070 r = su->scale * 0.006;
1076 r = su->scale / 12.0;
1080 r = su->scale * 0.6;
1088 ri = r > 0.0 ? r + 0.4995 : r - 0.4995;
1089 return ri < 66 ? ri : 1;
1093 * Convert a scaling width to basic units, rounding towards 0.
1096 term_hspan(const struct termp *p, const struct roffsu *su)
1099 return (*p->hspan)(p, su);
1103 * Convert a scaling width to basic units, rounding to closest.
1106 term_hen(const struct termp *p, const struct roffsu *su)
1110 if ((bu = (*p->hspan)(p, su)) >= 0)
1111 return (bu + 11) / 24;
1113 return -((-bu + 11) / 24);