mandoc(1): Update to 1.9.14.
[dragonfly.git] / usr.bin / mandoc / term.c
CommitLineData
4a06b3fd 1/* $Id: term.c,v 1.127 2009/11/12 08:21:06 kristaps Exp $ */
589e7c1d
SW
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 */
4a06b3fd
SW
17#include <sys/types.h>
18
589e7c1d 19#include <assert.h>
4a06b3fd 20#include <ctype.h>
589e7c1d
SW
21#include <stdio.h>
22#include <stdlib.h>
23#include <string.h>
0dd4f147 24#include <time.h>
589e7c1d
SW
25
26#include "chars.h"
27#include "out.h"
28#include "term.h"
29#include "man.h"
30#include "mdoc.h"
31#include "main.h"
32
589e7c1d
SW
33static struct termp *term_alloc(enum termenc);
34static void term_free(struct termp *);
4a06b3fd
SW
35static void spec(struct termp *, const char *, size_t);
36static void res(struct termp *, const char *, size_t);
37static void buffera(struct termp *, const char *, size_t);
38static void bufferc(struct termp *, char);
39static void adjbuf(struct termp *p, size_t);
40static void encode(struct termp *, const char *, size_t);
589e7c1d
SW
41
42
43void *
44ascii_alloc(void)
45{
46
47 return(term_alloc(TERMENC_ASCII));
48}
49
50
51void
52terminal_free(void *arg)
53{
54
55 term_free((struct termp *)arg);
56}
57
58
59static void
60term_free(struct termp *p)
61{
62
63 if (p->buf)
64 free(p->buf);
65 if (p->symtab)
66 chars_free(p->symtab);
67
68 free(p);
69}
70
71
72static struct termp *
73term_alloc(enum termenc enc)
74{
75 struct termp *p;
76
0dd4f147
SW
77 p = calloc(1, sizeof(struct termp));
78 if (NULL == p) {
79 perror(NULL);
80 exit(EXIT_FAILURE);
81 }
589e7c1d
SW
82 p->maxrmargin = 78;
83 p->enc = enc;
84 return(p);
85}
86
87
88/*
89 * Flush a line of text. A "line" is loosely defined as being something
90 * that should be followed by a newline, regardless of whether it's
91 * broken apart by newlines getting there. A line can also be a
92 * fragment of a columnar list.
93 *
94 * Specifically, a line is whatever's in p->buf of length p->col, which
95 * is zeroed after this function returns.
96 *
97 * The usage of termp:flags is as follows:
98 *
99 * - TERMP_NOLPAD: when beginning to write the line, don't left-pad the
100 * offset value. This is useful when doing columnar lists where the
101 * prior column has right-padded.
102 *
103 * - TERMP_NOBREAK: this is the most important and is used when making
104 * columns. In short: don't print a newline and instead pad to the
105 * right margin. Used in conjunction with TERMP_NOLPAD.
106 *
107 * - TERMP_TWOSPACE: when padding, make sure there are at least two
108 * space characters of padding. Otherwise, rather break the line.
109 *
110 * - TERMP_DANGLE: don't newline when TERMP_NOBREAK is specified and
111 * the line is overrun, and don't pad-right if it's underrun.
112 *
113 * - TERMP_HANG: like TERMP_DANGLE, but doesn't newline when
114 * overruning, instead save the position and continue at that point
115 * when the next invocation.
116 *
117 * In-line line breaking:
118 *
119 * If TERMP_NOBREAK is specified and the line overruns the right
120 * margin, it will break and pad-right to the right margin after
121 * writing. If maxrmargin is violated, it will break and continue
0dd4f147
SW
122 * writing from the right-margin, which will lead to the above scenario
123 * upon exit. Otherwise, the line will break at the right margin.
589e7c1d
SW
124 */
125void
126term_flushln(struct termp *p)
127{
0dd4f147
SW
128 int i; /* current input position in p->buf */
129 size_t vis; /* current visual position on output */
130 size_t vbl; /* number of blanks to prepend to output */
131 size_t vsz; /* visual characters to write to output */
132 size_t bp; /* visual right border position */
133 int j; /* temporary loop index */
134 size_t maxvis, mmax;
589e7c1d
SW
135 static int overstep = 0;
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);
589e7c1d 145
0dd4f147
SW
146 maxvis = (int)(p->rmargin - p->offset) - overstep < 0 ?
147 /* LINTED */
148 0 : p->rmargin - p->offset - overstep;
149 mmax = (int)(p->maxrmargin - p->offset) - overstep < 0 ?
150 /* LINTED */
151 0 : p->maxrmargin - p->offset - overstep;
589e7c1d
SW
152
153 bp = TERMP_NOBREAK & p->flags ? mmax : maxvis;
0dd4f147
SW
154
155 /*
156 * FIXME: if bp is zero, we still output the first word before
157 * breaking the line.
158 */
159
589e7c1d
SW
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 else 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 vbl = (size_t)(0 == vis ? 0 : 1);
197
198 /*
199 * Find out whether we would exceed the right margin.
200 * If so, break to the next line. (TODO: hyphenate)
201 * Otherwise, write the chosen number of blanks now.
202 */
203 if (vis && vis + vbl + vsz > bp) {
204 putchar('\n');
205 if (TERMP_NOBREAK & p->flags) {
206 for (j = 0; j < (int)p->rmargin; j++)
207 putchar(' ');
208 vis = p->rmargin - p->offset;
209 } else {
210 for (j = 0; j < (int)p->offset; j++)
211 putchar(' ');
212 vis = 0;
213 }
214 /* Remove the overstep width. */
cbce6d97
SW
215 bp += (int)/* LINTED */
216 overstep;
589e7c1d
SW
217 overstep = 0;
218 } else {
219 for (j = 0; j < (int)vbl; j++)
220 putchar(' ');
221 vis += vbl;
222 }
223
224 /*
225 * Finally, write out the word.
226 */
227 for ( ; i < (int)p->col; i++) {
228 if (' ' == p->buf[i])
229 break;
4a06b3fd
SW
230
231 /* The unit sep. is a non-breaking space. */
232 if (31 == p->buf[i])
233 putchar(' ');
234 else
235 putchar(p->buf[i]);
589e7c1d
SW
236 }
237 vis += vsz;
238 }
cbce6d97 239
589e7c1d 240 p->col = 0;
cbce6d97 241 overstep = 0;
589e7c1d
SW
242
243 if ( ! (TERMP_NOBREAK & p->flags)) {
244 putchar('\n');
245 return;
246 }
247
589e7c1d
SW
248 if (TERMP_HANG & p->flags) {
249 /* We need one blank after the tag. */
250 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 (overstep >= -1) {
264 assert((int)maxvis + overstep >= 0);
265 /* LINTED */
266 maxvis += overstep;
267 } else
268 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 */
291void
292term_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 */
311void
312term_vspace(struct termp *p)
313{
314
315 term_newln(p);
316 putchar('\n');
317}
318
319
320static void
4a06b3fd 321spec(struct termp *p, const char *word, size_t len)
589e7c1d
SW
322{
323 const char *rhs;
324 size_t sz;
589e7c1d
SW
325
326 rhs = chars_a2ascii(p->symtab, word, len, &sz);
4a06b3fd
SW
327 if (rhs)
328 encode(p, rhs, sz);
589e7c1d
SW
329}
330
331
332static void
4a06b3fd 333res(struct termp *p, const char *word, size_t len)
589e7c1d
SW
334{
335 const char *rhs;
336 size_t sz;
589e7c1d
SW
337
338 rhs = chars_a2res(p->symtab, word, len, &sz);
4a06b3fd
SW
339 if (rhs)
340 encode(p, rhs, sz);
341}
589e7c1d 342
4a06b3fd
SW
343
344void
345term_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;
589e7c1d
SW
352}
353
354
4a06b3fd
SW
355void
356term_fontrepl(struct termp *p, enum termfont f)
589e7c1d 357{
589e7c1d 358
4a06b3fd
SW
359 p->fontl = p->fontq[p->fonti];
360 p->fontq[p->fonti] = f;
361}
589e7c1d 362
589e7c1d 363
4a06b3fd
SW
364void
365term_fontpush(struct termp *p, enum termfont f)
366{
589e7c1d 367
4a06b3fd
SW
368 assert(p->fonti + 1 < 10);
369 p->fontl = p->fontq[p->fonti];
370 p->fontq[++p->fonti] = f;
371}
589e7c1d 372
589e7c1d 373
4a06b3fd
SW
374const void *
375term_fontq(struct termp *p)
376{
589e7c1d 377
4a06b3fd
SW
378 return(&p->fontq[p->fonti]);
379}
589e7c1d 380
589e7c1d 381
4a06b3fd
SW
382enum termfont
383term_fonttop(struct termp *p)
384{
589e7c1d 385
4a06b3fd
SW
386 return(p->fontq[p->fonti]);
387}
589e7c1d 388
589e7c1d 389
4a06b3fd
SW
390void
391term_fontpopq(struct termp *p, const void *key)
392{
589e7c1d 393
4a06b3fd
SW
394 while (p->fonti >= 0 && key != &p->fontq[p->fonti])
395 p->fonti--;
396 assert(p->fonti >= 0);
397}
589e7c1d 398
4a06b3fd
SW
399
400void
401term_fontpop(struct termp *p)
402{
403
404 assert(p->fonti);
405 p->fonti--;
589e7c1d
SW
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 */
414void
415term_word(struct termp *p, const char *word)
416{
4a06b3fd
SW
417 const char *sv, *seq;
418 int sz;
419 size_t ssz;
420 enum roffdeco deco;
589e7c1d
SW
421
422 sv = word;
423
4a06b3fd 424 if (word[0] && '\0' == word[1])
589e7c1d
SW
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 /* FALLTHROUGH */
442 case('}'):
443 if ( ! (TERMP_IGNDELIM & p->flags))
444 p->flags |= TERMP_NOSPACE;
445 break;
446 default:
447 break;
448 }
449
450 if ( ! (TERMP_NOSPACE & p->flags))
4a06b3fd 451 bufferc(p, ' ');
589e7c1d
SW
452
453 if ( ! (p->flags & TERMP_NONOSPACE))
454 p->flags &= ~TERMP_NOSPACE;
455
4a06b3fd
SW
456 /* FIXME: use strcspn. */
457
458 while (*word) {
459 if ('\\' != *word) {
460 encode(p, word, 1);
461 word++;
462 continue;
463 }
464
465 seq = ++word;
466 sz = a2roffdeco(&deco, &seq, &ssz);
467
468 switch (deco) {
469 case (DECO_RESERVED):
470 res(p, seq, ssz);
471 break;
472 case (DECO_SPECIAL):
473 spec(p, seq, ssz);
474 break;
475 case (DECO_BOLD):
476 term_fontrepl(p, TERMFONT_BOLD);
477 break;
478 case (DECO_ITALIC):
479 term_fontrepl(p, TERMFONT_UNDER);
480 break;
481 case (DECO_ROMAN):
482 term_fontrepl(p, TERMFONT_NONE);
483 break;
484 case (DECO_PREVIOUS):
485 term_fontlast(p);
486 break;
487 default:
488 break;
489 }
490
491 word += sz;
492 if (DECO_NOSPACE == deco && '\0' == *word)
493 p->flags |= TERMP_NOSPACE;
494 }
589e7c1d
SW
495
496 if (sv[0] && 0 == sv[1])
497 switch (sv[0]) {
498 case('('):
499 /* FALLTHROUGH */
500 case('['):
501 /* FALLTHROUGH */
502 case('{'):
503 p->flags |= TERMP_NOSPACE;
504 break;
505 default:
506 break;
507 }
508}
509
510
589e7c1d 511static void
4a06b3fd 512adjbuf(struct termp *p, size_t sz)
589e7c1d 513{
4a06b3fd
SW
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);
589e7c1d 524 }
589e7c1d
SW
525}
526
527
528static void
4a06b3fd 529buffera(struct termp *p, const char *word, size_t sz)
589e7c1d
SW
530{
531
4a06b3fd
SW
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
540static void
541bufferc(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
551static void
552encode(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;
cbce6d97 572 }
4a06b3fd
SW
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]);
589e7c1d 581 }
589e7c1d
SW
582}
583
584
585size_t
586term_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
621size_t
622term_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}