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