]> git.cameronkatri.com Git - mandoc.git/blob - mdoc_term.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
The upcoming .while request will have to re-execute roff(7) lines
[mandoc.git] / mdoc_term.c
1 /* $Id: mdoc_term.c,v 1.368 2018/08/17 20:33:38 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010, 2012-2018 Ingo Schwarze <schwarze@openbsd.org>
5 * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19 #include "config.h"
20
21 #include <sys/types.h>
22
23 #include <assert.h>
24 #include <ctype.h>
25 #include <limits.h>
26 #include <stdint.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #include "mandoc_aux.h"
32 #include "mandoc.h"
33 #include "roff.h"
34 #include "mdoc.h"
35 #include "out.h"
36 #include "term.h"
37 #include "tag.h"
38 #include "main.h"
39
40 struct termpair {
41 struct termpair *ppair;
42 int count;
43 };
44
45 #define DECL_ARGS struct termp *p, \
46 struct termpair *pair, \
47 const struct roff_meta *meta, \
48 struct roff_node *n
49
50 struct mdoc_term_act {
51 int (*pre)(DECL_ARGS);
52 void (*post)(DECL_ARGS);
53 };
54
55 static int a2width(const struct termp *, const char *);
56
57 static void print_bvspace(struct termp *,
58 const struct roff_node *,
59 const struct roff_node *);
60 static void print_mdoc_node(DECL_ARGS);
61 static void print_mdoc_nodelist(DECL_ARGS);
62 static void print_mdoc_head(struct termp *, const struct roff_meta *);
63 static void print_mdoc_foot(struct termp *, const struct roff_meta *);
64 static void synopsis_pre(struct termp *,
65 const struct roff_node *);
66
67 static void termp____post(DECL_ARGS);
68 static void termp__t_post(DECL_ARGS);
69 static void termp_bd_post(DECL_ARGS);
70 static void termp_bk_post(DECL_ARGS);
71 static void termp_bl_post(DECL_ARGS);
72 static void termp_eo_post(DECL_ARGS);
73 static void termp_fd_post(DECL_ARGS);
74 static void termp_fo_post(DECL_ARGS);
75 static void termp_in_post(DECL_ARGS);
76 static void termp_it_post(DECL_ARGS);
77 static void termp_lb_post(DECL_ARGS);
78 static void termp_nm_post(DECL_ARGS);
79 static void termp_pf_post(DECL_ARGS);
80 static void termp_quote_post(DECL_ARGS);
81 static void termp_sh_post(DECL_ARGS);
82 static void termp_ss_post(DECL_ARGS);
83 static void termp_xx_post(DECL_ARGS);
84
85 static int termp__a_pre(DECL_ARGS);
86 static int termp__t_pre(DECL_ARGS);
87 static int termp_an_pre(DECL_ARGS);
88 static int termp_ap_pre(DECL_ARGS);
89 static int termp_bd_pre(DECL_ARGS);
90 static int termp_bf_pre(DECL_ARGS);
91 static int termp_bk_pre(DECL_ARGS);
92 static int termp_bl_pre(DECL_ARGS);
93 static int termp_bold_pre(DECL_ARGS);
94 static int termp_cd_pre(DECL_ARGS);
95 static int termp_d1_pre(DECL_ARGS);
96 static int termp_eo_pre(DECL_ARGS);
97 static int termp_em_pre(DECL_ARGS);
98 static int termp_er_pre(DECL_ARGS);
99 static int termp_ex_pre(DECL_ARGS);
100 static int termp_fa_pre(DECL_ARGS);
101 static int termp_fd_pre(DECL_ARGS);
102 static int termp_fl_pre(DECL_ARGS);
103 static int termp_fn_pre(DECL_ARGS);
104 static int termp_fo_pre(DECL_ARGS);
105 static int termp_ft_pre(DECL_ARGS);
106 static int termp_in_pre(DECL_ARGS);
107 static int termp_it_pre(DECL_ARGS);
108 static int termp_li_pre(DECL_ARGS);
109 static int termp_lk_pre(DECL_ARGS);
110 static int termp_nd_pre(DECL_ARGS);
111 static int termp_nm_pre(DECL_ARGS);
112 static int termp_ns_pre(DECL_ARGS);
113 static int termp_quote_pre(DECL_ARGS);
114 static int termp_rs_pre(DECL_ARGS);
115 static int termp_sh_pre(DECL_ARGS);
116 static int termp_skip_pre(DECL_ARGS);
117 static int termp_sm_pre(DECL_ARGS);
118 static int termp_pp_pre(DECL_ARGS);
119 static int termp_ss_pre(DECL_ARGS);
120 static int termp_sy_pre(DECL_ARGS);
121 static int termp_tag_pre(DECL_ARGS);
122 static int termp_under_pre(DECL_ARGS);
123 static int termp_vt_pre(DECL_ARGS);
124 static int termp_xr_pre(DECL_ARGS);
125 static int termp_xx_pre(DECL_ARGS);
126
127 static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = {
128 { NULL, NULL }, /* Dd */
129 { NULL, NULL }, /* Dt */
130 { NULL, NULL }, /* Os */
131 { termp_sh_pre, termp_sh_post }, /* Sh */
132 { termp_ss_pre, termp_ss_post }, /* Ss */
133 { termp_pp_pre, NULL }, /* Pp */
134 { termp_d1_pre, termp_bl_post }, /* D1 */
135 { termp_d1_pre, termp_bl_post }, /* Dl */
136 { termp_bd_pre, termp_bd_post }, /* Bd */
137 { NULL, NULL }, /* Ed */
138 { termp_bl_pre, termp_bl_post }, /* Bl */
139 { NULL, NULL }, /* El */
140 { termp_it_pre, termp_it_post }, /* It */
141 { termp_under_pre, NULL }, /* Ad */
142 { termp_an_pre, NULL }, /* An */
143 { termp_ap_pre, NULL }, /* Ap */
144 { termp_under_pre, NULL }, /* Ar */
145 { termp_cd_pre, NULL }, /* Cd */
146 { termp_bold_pre, NULL }, /* Cm */
147 { termp_li_pre, NULL }, /* Dv */
148 { termp_er_pre, NULL }, /* Er */
149 { termp_tag_pre, NULL }, /* Ev */
150 { termp_ex_pre, NULL }, /* Ex */
151 { termp_fa_pre, NULL }, /* Fa */
152 { termp_fd_pre, termp_fd_post }, /* Fd */
153 { termp_fl_pre, NULL }, /* Fl */
154 { termp_fn_pre, NULL }, /* Fn */
155 { termp_ft_pre, NULL }, /* Ft */
156 { termp_bold_pre, NULL }, /* Ic */
157 { termp_in_pre, termp_in_post }, /* In */
158 { termp_li_pre, NULL }, /* Li */
159 { termp_nd_pre, NULL }, /* Nd */
160 { termp_nm_pre, termp_nm_post }, /* Nm */
161 { termp_quote_pre, termp_quote_post }, /* Op */
162 { termp_ft_pre, NULL }, /* Ot */
163 { termp_under_pre, NULL }, /* Pa */
164 { termp_ex_pre, NULL }, /* Rv */
165 { NULL, NULL }, /* St */
166 { termp_under_pre, NULL }, /* Va */
167 { termp_vt_pre, NULL }, /* Vt */
168 { termp_xr_pre, NULL }, /* Xr */
169 { termp__a_pre, termp____post }, /* %A */
170 { termp_under_pre, termp____post }, /* %B */
171 { NULL, termp____post }, /* %D */
172 { termp_under_pre, termp____post }, /* %I */
173 { termp_under_pre, termp____post }, /* %J */
174 { NULL, termp____post }, /* %N */
175 { NULL, termp____post }, /* %O */
176 { NULL, termp____post }, /* %P */
177 { NULL, termp____post }, /* %R */
178 { termp__t_pre, termp__t_post }, /* %T */
179 { NULL, termp____post }, /* %V */
180 { NULL, NULL }, /* Ac */
181 { termp_quote_pre, termp_quote_post }, /* Ao */
182 { termp_quote_pre, termp_quote_post }, /* Aq */
183 { NULL, NULL }, /* At */
184 { NULL, NULL }, /* Bc */
185 { termp_bf_pre, NULL }, /* Bf */
186 { termp_quote_pre, termp_quote_post }, /* Bo */
187 { termp_quote_pre, termp_quote_post }, /* Bq */
188 { termp_xx_pre, termp_xx_post }, /* Bsx */
189 { NULL, NULL }, /* Bx */
190 { termp_skip_pre, NULL }, /* Db */
191 { NULL, NULL }, /* Dc */
192 { termp_quote_pre, termp_quote_post }, /* Do */
193 { termp_quote_pre, termp_quote_post }, /* Dq */
194 { NULL, NULL }, /* Ec */ /* FIXME: no space */
195 { NULL, NULL }, /* Ef */
196 { termp_em_pre, NULL }, /* Em */
197 { termp_eo_pre, termp_eo_post }, /* Eo */
198 { termp_xx_pre, termp_xx_post }, /* Fx */
199 { termp_bold_pre, NULL }, /* Ms */
200 { termp_li_pre, NULL }, /* No */
201 { termp_ns_pre, NULL }, /* Ns */
202 { termp_xx_pre, termp_xx_post }, /* Nx */
203 { termp_xx_pre, termp_xx_post }, /* Ox */
204 { NULL, NULL }, /* Pc */
205 { NULL, termp_pf_post }, /* Pf */
206 { termp_quote_pre, termp_quote_post }, /* Po */
207 { termp_quote_pre, termp_quote_post }, /* Pq */
208 { NULL, NULL }, /* Qc */
209 { termp_quote_pre, termp_quote_post }, /* Ql */
210 { termp_quote_pre, termp_quote_post }, /* Qo */
211 { termp_quote_pre, termp_quote_post }, /* Qq */
212 { NULL, NULL }, /* Re */
213 { termp_rs_pre, NULL }, /* Rs */
214 { NULL, NULL }, /* Sc */
215 { termp_quote_pre, termp_quote_post }, /* So */
216 { termp_quote_pre, termp_quote_post }, /* Sq */
217 { termp_sm_pre, NULL }, /* Sm */
218 { termp_under_pre, NULL }, /* Sx */
219 { termp_sy_pre, NULL }, /* Sy */
220 { NULL, NULL }, /* Tn */
221 { termp_xx_pre, termp_xx_post }, /* Ux */
222 { NULL, NULL }, /* Xc */
223 { NULL, NULL }, /* Xo */
224 { termp_fo_pre, termp_fo_post }, /* Fo */
225 { NULL, NULL }, /* Fc */
226 { termp_quote_pre, termp_quote_post }, /* Oo */
227 { NULL, NULL }, /* Oc */
228 { termp_bk_pre, termp_bk_post }, /* Bk */
229 { NULL, NULL }, /* Ek */
230 { NULL, NULL }, /* Bt */
231 { NULL, NULL }, /* Hf */
232 { termp_under_pre, NULL }, /* Fr */
233 { NULL, NULL }, /* Ud */
234 { NULL, termp_lb_post }, /* Lb */
235 { termp_pp_pre, NULL }, /* Lp */
236 { termp_lk_pre, NULL }, /* Lk */
237 { termp_under_pre, NULL }, /* Mt */
238 { termp_quote_pre, termp_quote_post }, /* Brq */
239 { termp_quote_pre, termp_quote_post }, /* Bro */
240 { NULL, NULL }, /* Brc */
241 { NULL, termp____post }, /* %C */
242 { termp_skip_pre, NULL }, /* Es */
243 { termp_quote_pre, termp_quote_post }, /* En */
244 { termp_xx_pre, termp_xx_post }, /* Dx */
245 { NULL, termp____post }, /* %Q */
246 { NULL, termp____post }, /* %U */
247 { NULL, NULL }, /* Ta */
248 };
249
250 static int fn_prio;
251
252
253 void
254 terminal_mdoc(void *arg, const struct roff_man *mdoc)
255 {
256 struct roff_node *n;
257 struct termp *p;
258 size_t save_defindent;
259
260 p = (struct termp *)arg;
261 p->tcol->rmargin = p->maxrmargin = p->defrmargin;
262 term_tab_set(p, NULL);
263 term_tab_set(p, "T");
264 term_tab_set(p, ".5i");
265
266 n = mdoc->first->child;
267 if (p->synopsisonly) {
268 while (n != NULL) {
269 if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {
270 if (n->child->next->child != NULL)
271 print_mdoc_nodelist(p, NULL,
272 &mdoc->meta,
273 n->child->next->child);
274 term_newln(p);
275 break;
276 }
277 n = n->next;
278 }
279 } else {
280 save_defindent = p->defindent;
281 if (p->defindent == 0)
282 p->defindent = 5;
283 term_begin(p, print_mdoc_head, print_mdoc_foot,
284 &mdoc->meta);
285 while (n != NULL &&
286 (n->type == ROFFT_COMMENT ||
287 n->flags & NODE_NOPRT))
288 n = n->next;
289 if (n != NULL) {
290 if (n->tok != MDOC_Sh)
291 term_vspace(p);
292 print_mdoc_nodelist(p, NULL, &mdoc->meta, n);
293 }
294 term_end(p);
295 p->defindent = save_defindent;
296 }
297 }
298
299 static void
300 print_mdoc_nodelist(DECL_ARGS)
301 {
302
303 while (n != NULL) {
304 print_mdoc_node(p, pair, meta, n);
305 n = n->next;
306 }
307 }
308
309 static void
310 print_mdoc_node(DECL_ARGS)
311 {
312 const struct mdoc_term_act *act;
313 struct termpair npair;
314 size_t offset, rmargin;
315 int chld;
316
317 if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
318 return;
319
320 chld = 1;
321 offset = p->tcol->offset;
322 rmargin = p->tcol->rmargin;
323 n->flags &= ~NODE_ENDED;
324 n->prev_font = p->fonti;
325
326 memset(&npair, 0, sizeof(struct termpair));
327 npair.ppair = pair;
328
329 /*
330 * Keeps only work until the end of a line. If a keep was
331 * invoked in a prior line, revert it to PREKEEP.
332 */
333
334 if (p->flags & TERMP_KEEP && n->flags & NODE_LINE) {
335 p->flags &= ~TERMP_KEEP;
336 p->flags |= TERMP_PREKEEP;
337 }
338
339 /*
340 * After the keep flags have been set up, we may now
341 * produce output. Note that some pre-handlers do so.
342 */
343
344 switch (n->type) {
345 case ROFFT_TEXT:
346 if (*n->string == ' ' && n->flags & NODE_LINE &&
347 (p->flags & TERMP_NONEWLINE) == 0)
348 term_newln(p);
349 if (NODE_DELIMC & n->flags)
350 p->flags |= TERMP_NOSPACE;
351 term_word(p, n->string);
352 if (NODE_DELIMO & n->flags)
353 p->flags |= TERMP_NOSPACE;
354 break;
355 case ROFFT_EQN:
356 if ( ! (n->flags & NODE_LINE))
357 p->flags |= TERMP_NOSPACE;
358 term_eqn(p, n->eqn);
359 if (n->next != NULL && ! (n->next->flags & NODE_LINE))
360 p->flags |= TERMP_NOSPACE;
361 break;
362 case ROFFT_TBL:
363 if (p->tbl.cols == NULL)
364 term_newln(p);
365 term_tbl(p, n->span);
366 break;
367 default:
368 if (n->tok < ROFF_MAX) {
369 roff_term_pre(p, n);
370 return;
371 }
372 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
373 act = mdoc_term_acts + (n->tok - MDOC_Dd);
374 if (act->pre != NULL &&
375 (n->end == ENDBODY_NOT || n->child != NULL))
376 chld = (*act->pre)(p, &npair, meta, n);
377 break;
378 }
379
380 if (chld && n->child)
381 print_mdoc_nodelist(p, &npair, meta, n->child);
382
383 term_fontpopq(p,
384 (ENDBODY_NOT == n->end ? n : n->body)->prev_font);
385
386 switch (n->type) {
387 case ROFFT_TEXT:
388 break;
389 case ROFFT_TBL:
390 break;
391 case ROFFT_EQN:
392 break;
393 default:
394 if (act->post == NULL || n->flags & NODE_ENDED)
395 break;
396 (void)(*act->post)(p, &npair, meta, n);
397
398 /*
399 * Explicit end tokens not only call the post
400 * handler, but also tell the respective block
401 * that it must not call the post handler again.
402 */
403 if (ENDBODY_NOT != n->end)
404 n->body->flags |= NODE_ENDED;
405 break;
406 }
407
408 if (NODE_EOS & n->flags)
409 p->flags |= TERMP_SENTENCE;
410
411 if (n->type != ROFFT_TEXT)
412 p->tcol->offset = offset;
413 p->tcol->rmargin = rmargin;
414 }
415
416 static void
417 print_mdoc_foot(struct termp *p, const struct roff_meta *meta)
418 {
419 size_t sz;
420
421 term_fontrepl(p, TERMFONT_NONE);
422
423 /*
424 * Output the footer in new-groff style, that is, three columns
425 * with the middle being the manual date and flanking columns
426 * being the operating system:
427 *
428 * SYSTEM DATE SYSTEM
429 */
430
431 term_vspace(p);
432
433 p->tcol->offset = 0;
434 sz = term_strlen(p, meta->date);
435 p->tcol->rmargin = p->maxrmargin > sz ?
436 (p->maxrmargin + term_len(p, 1) - sz) / 2 : 0;
437 p->trailspace = 1;
438 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
439
440 term_word(p, meta->os);
441 term_flushln(p);
442
443 p->tcol->offset = p->tcol->rmargin;
444 sz = term_strlen(p, meta->os);
445 p->tcol->rmargin = p->maxrmargin > sz ? p->maxrmargin - sz : 0;
446 p->flags |= TERMP_NOSPACE;
447
448 term_word(p, meta->date);
449 term_flushln(p);
450
451 p->tcol->offset = p->tcol->rmargin;
452 p->tcol->rmargin = p->maxrmargin;
453 p->trailspace = 0;
454 p->flags &= ~TERMP_NOBREAK;
455 p->flags |= TERMP_NOSPACE;
456
457 term_word(p, meta->os);
458 term_flushln(p);
459
460 p->tcol->offset = 0;
461 p->tcol->rmargin = p->maxrmargin;
462 p->flags = 0;
463 }
464
465 static void
466 print_mdoc_head(struct termp *p, const struct roff_meta *meta)
467 {
468 char *volume, *title;
469 size_t vollen, titlen;
470
471 /*
472 * The header is strange. It has three components, which are
473 * really two with the first duplicated. It goes like this:
474 *
475 * IDENTIFIER TITLE IDENTIFIER
476 *
477 * The IDENTIFIER is NAME(SECTION), which is the command-name
478 * (if given, or "unknown" if not) followed by the manual page
479 * section. These are given in `Dt'. The TITLE is a free-form
480 * string depending on the manual volume. If not specified, it
481 * switches on the manual section.
482 */
483
484 assert(meta->vol);
485 if (NULL == meta->arch)
486 volume = mandoc_strdup(meta->vol);
487 else
488 mandoc_asprintf(&volume, "%s (%s)",
489 meta->vol, meta->arch);
490 vollen = term_strlen(p, volume);
491
492 if (NULL == meta->msec)
493 title = mandoc_strdup(meta->title);
494 else
495 mandoc_asprintf(&title, "%s(%s)",
496 meta->title, meta->msec);
497 titlen = term_strlen(p, title);
498
499 p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
500 p->trailspace = 1;
501 p->tcol->offset = 0;
502 p->tcol->rmargin = 2 * (titlen+1) + vollen < p->maxrmargin ?
503 (p->maxrmargin - vollen + term_len(p, 1)) / 2 :
504 vollen < p->maxrmargin ? p->maxrmargin - vollen : 0;
505
506 term_word(p, title);
507 term_flushln(p);
508
509 p->flags |= TERMP_NOSPACE;
510 p->tcol->offset = p->tcol->rmargin;
511 p->tcol->rmargin = p->tcol->offset + vollen + titlen <
512 p->maxrmargin ? p->maxrmargin - titlen : p->maxrmargin;
513
514 term_word(p, volume);
515 term_flushln(p);
516
517 p->flags &= ~TERMP_NOBREAK;
518 p->trailspace = 0;
519 if (p->tcol->rmargin + titlen <= p->maxrmargin) {
520 p->flags |= TERMP_NOSPACE;
521 p->tcol->offset = p->tcol->rmargin;
522 p->tcol->rmargin = p->maxrmargin;
523 term_word(p, title);
524 term_flushln(p);
525 }
526
527 p->flags &= ~TERMP_NOSPACE;
528 p->tcol->offset = 0;
529 p->tcol->rmargin = p->maxrmargin;
530 free(title);
531 free(volume);
532 }
533
534 static int
535 a2width(const struct termp *p, const char *v)
536 {
537 struct roffsu su;
538 const char *end;
539
540 end = a2roffsu(v, &su, SCALE_MAX);
541 if (end == NULL || *end != '\0') {
542 SCALE_HS_INIT(&su, term_strlen(p, v));
543 su.scale /= term_strlen(p, "0");
544 }
545 return term_hen(p, &su);
546 }
547
548 /*
549 * Determine how much space to print out before block elements of `It'
550 * (and thus `Bl') and `Bd'. And then go ahead and print that space,
551 * too.
552 */
553 static void
554 print_bvspace(struct termp *p,
555 const struct roff_node *bl,
556 const struct roff_node *n)
557 {
558 const struct roff_node *nn;
559
560 assert(n);
561
562 term_newln(p);
563
564 if (MDOC_Bd == bl->tok && bl->norm->Bd.comp)
565 return;
566 if (MDOC_Bl == bl->tok && bl->norm->Bl.comp)
567 return;
568
569 /* Do not vspace directly after Ss/Sh. */
570
571 nn = n;
572 while (nn->prev != NULL &&
573 (nn->prev->type == ROFFT_COMMENT ||
574 nn->prev->flags & NODE_NOPRT))
575 nn = nn->prev;
576 while (nn->prev == NULL) {
577 do {
578 nn = nn->parent;
579 if (nn->type == ROFFT_ROOT)
580 return;
581 } while (nn->type != ROFFT_BLOCK);
582 if (nn->tok == MDOC_Sh || nn->tok == MDOC_Ss)
583 return;
584 if (nn->tok == MDOC_It &&
585 nn->parent->parent->norm->Bl.type != LIST_item)
586 break;
587 }
588
589 /* A `-column' does not assert vspace within the list. */
590
591 if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type)
592 if (n->prev && MDOC_It == n->prev->tok)
593 return;
594
595 /* A `-diag' without body does not vspace. */
596
597 if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type)
598 if (n->prev && MDOC_It == n->prev->tok) {
599 assert(n->prev->body);
600 if (NULL == n->prev->body->child)
601 return;
602 }
603
604 term_vspace(p);
605 }
606
607
608 static int
609 termp_it_pre(DECL_ARGS)
610 {
611 struct roffsu su;
612 char buf[24];
613 const struct roff_node *bl, *nn;
614 size_t ncols, dcol;
615 int i, offset, width;
616 enum mdoc_list type;
617
618 if (n->type == ROFFT_BLOCK) {
619 print_bvspace(p, n->parent->parent, n);
620 return 1;
621 }
622
623 bl = n->parent->parent->parent;
624 type = bl->norm->Bl.type;
625
626 /*
627 * Defaults for specific list types.
628 */
629
630 switch (type) {
631 case LIST_bullet:
632 case LIST_dash:
633 case LIST_hyphen:
634 case LIST_enum:
635 width = term_len(p, 2);
636 break;
637 case LIST_hang:
638 case LIST_tag:
639 width = term_len(p, 8);
640 break;
641 case LIST_column:
642 width = term_len(p, 10);
643 break;
644 default:
645 width = 0;
646 break;
647 }
648 offset = 0;
649
650 /*
651 * First calculate width and offset. This is pretty easy unless
652 * we're a -column list, in which case all prior columns must
653 * be accounted for.
654 */
655
656 if (bl->norm->Bl.offs != NULL) {
657 offset = a2width(p, bl->norm->Bl.offs);
658 if (offset < 0 && (size_t)(-offset) > p->tcol->offset)
659 offset = -p->tcol->offset;
660 else if (offset > SHRT_MAX)
661 offset = 0;
662 }
663
664 switch (type) {
665 case LIST_column:
666 if (n->type == ROFFT_HEAD)
667 break;
668
669 /*
670 * Imitate groff's column handling:
671 * - For each earlier column, add its width.
672 * - For less than 5 columns, add four more blanks per
673 * column.
674 * - For exactly 5 columns, add three more blank per
675 * column.
676 * - For more than 5 columns, add only one column.
677 */
678 ncols = bl->norm->Bl.ncols;
679 dcol = ncols < 5 ? term_len(p, 4) :
680 ncols == 5 ? term_len(p, 3) : term_len(p, 1);
681
682 /*
683 * Calculate the offset by applying all prior ROFFT_BODY,
684 * so we stop at the ROFFT_HEAD (nn->prev == NULL).
685 */
686
687 for (i = 0, nn = n->prev;
688 nn->prev && i < (int)ncols;
689 nn = nn->prev, i++) {
690 SCALE_HS_INIT(&su,
691 term_strlen(p, bl->norm->Bl.cols[i]));
692 su.scale /= term_strlen(p, "0");
693 offset += term_hen(p, &su) + dcol;
694 }
695
696 /*
697 * When exceeding the declared number of columns, leave
698 * the remaining widths at 0. This will later be
699 * adjusted to the default width of 10, or, for the last
700 * column, stretched to the right margin.
701 */
702 if (i >= (int)ncols)
703 break;
704
705 /*
706 * Use the declared column widths, extended as explained
707 * in the preceding paragraph.
708 */
709 SCALE_HS_INIT(&su, term_strlen(p, bl->norm->Bl.cols[i]));
710 su.scale /= term_strlen(p, "0");
711 width = term_hen(p, &su) + dcol;
712 break;
713 default:
714 if (NULL == bl->norm->Bl.width)
715 break;
716
717 /*
718 * Note: buffer the width by 2, which is groff's magic
719 * number for buffering single arguments. See the above
720 * handling for column for how this changes.
721 */
722 width = a2width(p, bl->norm->Bl.width) + term_len(p, 2);
723 if (width < 0 && (size_t)(-width) > p->tcol->offset)
724 width = -p->tcol->offset;
725 else if (width > SHRT_MAX)
726 width = 0;
727 break;
728 }
729
730 /*
731 * Whitespace control. Inset bodies need an initial space,
732 * while diagonal bodies need two.
733 */
734
735 p->flags |= TERMP_NOSPACE;
736
737 switch (type) {
738 case LIST_diag:
739 if (n->type == ROFFT_BODY)
740 term_word(p, "\\ \\ ");
741 break;
742 case LIST_inset:
743 if (n->type == ROFFT_BODY && n->parent->head->child != NULL)
744 term_word(p, "\\ ");
745 break;
746 default:
747 break;
748 }
749
750 p->flags |= TERMP_NOSPACE;
751
752 switch (type) {
753 case LIST_diag:
754 if (n->type == ROFFT_HEAD)
755 term_fontpush(p, TERMFONT_BOLD);
756 break;
757 default:
758 break;
759 }
760
761 /*
762 * Pad and break control. This is the tricky part. These flags
763 * are documented in term_flushln() in term.c. Note that we're
764 * going to unset all of these flags in termp_it_post() when we
765 * exit.
766 */
767
768 switch (type) {
769 case LIST_enum:
770 case LIST_bullet:
771 case LIST_dash:
772 case LIST_hyphen:
773 if (n->type == ROFFT_HEAD) {
774 p->flags |= TERMP_NOBREAK | TERMP_HANG;
775 p->trailspace = 1;
776 } else if (width <= (int)term_len(p, 2))
777 p->flags |= TERMP_NOPAD;
778 break;
779 case LIST_hang:
780 if (n->type != ROFFT_HEAD)
781 break;
782 p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG;
783 p->trailspace = 1;
784 break;
785 case LIST_tag:
786 if (n->type != ROFFT_HEAD)
787 break;
788
789 p->flags |= TERMP_NOBREAK | TERMP_BRTRSP | TERMP_BRIND;
790 p->trailspace = 2;
791
792 if (NULL == n->next || NULL == n->next->child)
793 p->flags |= TERMP_HANG;
794 break;
795 case LIST_column:
796 if (n->type == ROFFT_HEAD)
797 break;
798
799 if (NULL == n->next) {
800 p->flags &= ~TERMP_NOBREAK;
801 p->trailspace = 0;
802 } else {
803 p->flags |= TERMP_NOBREAK;
804 p->trailspace = 1;
805 }
806
807 break;
808 case LIST_diag:
809 if (n->type != ROFFT_HEAD)
810 break;
811 p->flags |= TERMP_NOBREAK | TERMP_BRIND;
812 p->trailspace = 1;
813 break;
814 default:
815 break;
816 }
817
818 /*
819 * Margin control. Set-head-width lists have their right
820 * margins shortened. The body for these lists has the offset
821 * necessarily lengthened. Everybody gets the offset.
822 */
823
824 p->tcol->offset += offset;
825
826 switch (type) {
827 case LIST_bullet:
828 case LIST_dash:
829 case LIST_enum:
830 case LIST_hyphen:
831 case LIST_hang:
832 case LIST_tag:
833 if (n->type == ROFFT_HEAD)
834 p->tcol->rmargin = p->tcol->offset + width;
835 else
836 p->tcol->offset += width;
837 break;
838 case LIST_column:
839 assert(width);
840 p->tcol->rmargin = p->tcol->offset + width;
841 /*
842 * XXX - this behaviour is not documented: the
843 * right-most column is filled to the right margin.
844 */
845 if (n->type == ROFFT_HEAD)
846 break;
847 if (n->next == NULL && p->tcol->rmargin < p->maxrmargin)
848 p->tcol->rmargin = p->maxrmargin;
849 break;
850 default:
851 break;
852 }
853
854 /*
855 * The dash, hyphen, bullet and enum lists all have a special
856 * HEAD character (temporarily bold, in some cases).
857 */
858
859 if (n->type == ROFFT_HEAD)
860 switch (type) {
861 case LIST_bullet:
862 term_fontpush(p, TERMFONT_BOLD);
863 term_word(p, "\\[bu]");
864 term_fontpop(p);
865 break;
866 case LIST_dash:
867 case LIST_hyphen:
868 term_fontpush(p, TERMFONT_BOLD);
869 term_word(p, "-");
870 term_fontpop(p);
871 break;
872 case LIST_enum:
873 (pair->ppair->ppair->count)++;
874 (void)snprintf(buf, sizeof(buf), "%d.",
875 pair->ppair->ppair->count);
876 term_word(p, buf);
877 break;
878 default:
879 break;
880 }
881
882 /*
883 * If we're not going to process our children, indicate so here.
884 */
885
886 switch (type) {
887 case LIST_bullet:
888 case LIST_item:
889 case LIST_dash:
890 case LIST_hyphen:
891 case LIST_enum:
892 if (n->type == ROFFT_HEAD)
893 return 0;
894 break;
895 case LIST_column:
896 if (n->type == ROFFT_HEAD)
897 return 0;
898 p->minbl = 0;
899 break;
900 default:
901 break;
902 }
903
904 return 1;
905 }
906
907 static void
908 termp_it_post(DECL_ARGS)
909 {
910 enum mdoc_list type;
911
912 if (n->type == ROFFT_BLOCK)
913 return;
914
915 type = n->parent->parent->parent->norm->Bl.type;
916
917 switch (type) {
918 case LIST_item:
919 case LIST_diag:
920 case LIST_inset:
921 if (n->type == ROFFT_BODY)
922 term_newln(p);
923 break;
924 case LIST_column:
925 if (n->type == ROFFT_BODY)
926 term_flushln(p);
927 break;
928 default:
929 term_newln(p);
930 break;
931 }
932
933 /*
934 * Now that our output is flushed, we can reset our tags. Since
935 * only `It' sets these flags, we're free to assume that nobody
936 * has munged them in the meanwhile.
937 */
938
939 p->flags &= ~(TERMP_NOBREAK | TERMP_BRTRSP | TERMP_BRIND | TERMP_HANG);
940 p->trailspace = 0;
941 }
942
943 static int
944 termp_nm_pre(DECL_ARGS)
945 {
946 const char *cp;
947
948 if (n->type == ROFFT_BLOCK) {
949 p->flags |= TERMP_PREKEEP;
950 return 1;
951 }
952
953 if (n->type == ROFFT_BODY) {
954 if (n->child == NULL)
955 return 0;
956 p->flags |= TERMP_NOSPACE;
957 cp = NULL;
958 if (n->prev->child != NULL)
959 cp = n->prev->child->string;
960 if (cp == NULL)
961 cp = meta->name;
962 if (cp == NULL)
963 p->tcol->offset += term_len(p, 6);
964 else
965 p->tcol->offset += term_len(p, 1) +
966 term_strlen(p, cp);
967 return 1;
968 }
969
970 if (n->child == NULL)
971 return 0;
972
973 if (n->type == ROFFT_HEAD)
974 synopsis_pre(p, n->parent);
975
976 if (n->type == ROFFT_HEAD &&
977 n->next != NULL && n->next->child != NULL) {
978 p->flags |= TERMP_NOSPACE | TERMP_NOBREAK | TERMP_BRIND;
979 p->trailspace = 1;
980 p->tcol->rmargin = p->tcol->offset + term_len(p, 1);
981 if (n->child == NULL)
982 p->tcol->rmargin += term_strlen(p, meta->name);
983 else if (n->child->type == ROFFT_TEXT) {
984 p->tcol->rmargin += term_strlen(p, n->child->string);
985 if (n->child->next != NULL)
986 p->flags |= TERMP_HANG;
987 } else {
988 p->tcol->rmargin += term_len(p, 5);
989 p->flags |= TERMP_HANG;
990 }
991 }
992
993 term_fontpush(p, TERMFONT_BOLD);
994 return 1;
995 }
996
997 static void
998 termp_nm_post(DECL_ARGS)
999 {
1000
1001 if (n->type == ROFFT_BLOCK) {
1002 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
1003 } else if (n->type == ROFFT_HEAD &&
1004 NULL != n->next && NULL != n->next->child) {
1005 term_flushln(p);
1006 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);
1007 p->trailspace = 0;
1008 } else if (n->type == ROFFT_BODY && n->child != NULL)
1009 term_flushln(p);
1010 }
1011
1012 static int
1013 termp_fl_pre(DECL_ARGS)
1014 {
1015
1016 termp_tag_pre(p, pair, meta, n);
1017 term_fontpush(p, TERMFONT_BOLD);
1018 term_word(p, "\\-");
1019
1020 if (!(n->child == NULL &&
1021 (n->next == NULL ||
1022 n->next->type == ROFFT_TEXT ||
1023 n->next->flags & NODE_LINE)))
1024 p->flags |= TERMP_NOSPACE;
1025
1026 return 1;
1027 }
1028
1029 static int
1030 termp__a_pre(DECL_ARGS)
1031 {
1032
1033 if (n->prev && MDOC__A == n->prev->tok)
1034 if (NULL == n->next || MDOC__A != n->next->tok)
1035 term_word(p, "and");
1036
1037 return 1;
1038 }
1039
1040 static int
1041 termp_an_pre(DECL_ARGS)
1042 {
1043
1044 if (n->norm->An.auth == AUTH_split) {
1045 p->flags &= ~TERMP_NOSPLIT;
1046 p->flags |= TERMP_SPLIT;
1047 return 0;
1048 }
1049 if (n->norm->An.auth == AUTH_nosplit) {
1050 p->flags &= ~TERMP_SPLIT;
1051 p->flags |= TERMP_NOSPLIT;
1052 return 0;
1053 }
1054
1055 if (p->flags & TERMP_SPLIT)
1056 term_newln(p);
1057
1058 if (n->sec == SEC_AUTHORS && ! (p->flags & TERMP_NOSPLIT))
1059 p->flags |= TERMP_SPLIT;
1060
1061 return 1;
1062 }
1063
1064 static int
1065 termp_ns_pre(DECL_ARGS)
1066 {
1067
1068 if ( ! (NODE_LINE & n->flags))
1069 p->flags |= TERMP_NOSPACE;
1070 return 1;
1071 }
1072
1073 static int
1074 termp_rs_pre(DECL_ARGS)
1075 {
1076
1077 if (SEC_SEE_ALSO != n->sec)
1078 return 1;
1079 if (n->type == ROFFT_BLOCK && n->prev != NULL)
1080 term_vspace(p);
1081 return 1;
1082 }
1083
1084 static int
1085 termp_ex_pre(DECL_ARGS)
1086 {
1087 term_newln(p);
1088 return 1;
1089 }
1090
1091 static int
1092 termp_nd_pre(DECL_ARGS)
1093 {
1094
1095 if (n->type == ROFFT_BODY)
1096 term_word(p, "\\(en");
1097 return 1;
1098 }
1099
1100 static int
1101 termp_bl_pre(DECL_ARGS)
1102 {
1103
1104 return n->type != ROFFT_HEAD;
1105 }
1106
1107 static void
1108 termp_bl_post(DECL_ARGS)
1109 {
1110
1111 if (n->type != ROFFT_BLOCK)
1112 return;
1113 term_newln(p);
1114 if (n->tok != MDOC_Bl || n->norm->Bl.type != LIST_column)
1115 return;
1116 term_tab_set(p, NULL);
1117 term_tab_set(p, "T");
1118 term_tab_set(p, ".5i");
1119 }
1120
1121 static int
1122 termp_xr_pre(DECL_ARGS)
1123 {
1124
1125 if (NULL == (n = n->child))
1126 return 0;
1127
1128 assert(n->type == ROFFT_TEXT);
1129 term_word(p, n->string);
1130
1131 if (NULL == (n = n->next))
1132 return 0;
1133
1134 p->flags |= TERMP_NOSPACE;
1135 term_word(p, "(");
1136 p->flags |= TERMP_NOSPACE;
1137
1138 assert(n->type == ROFFT_TEXT);
1139 term_word(p, n->string);
1140
1141 p->flags |= TERMP_NOSPACE;
1142 term_word(p, ")");
1143
1144 return 0;
1145 }
1146
1147 /*
1148 * This decides how to assert whitespace before any of the SYNOPSIS set
1149 * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain
1150 * macro combos).
1151 */
1152 static void
1153 synopsis_pre(struct termp *p, const struct roff_node *n)
1154 {
1155 /*
1156 * Obviously, if we're not in a SYNOPSIS or no prior macros
1157 * exist, do nothing.
1158 */
1159 if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))
1160 return;
1161
1162 /*
1163 * If we're the second in a pair of like elements, emit our
1164 * newline and return. UNLESS we're `Fo', `Fn', `Fn', in which
1165 * case we soldier on.
1166 */
1167 if (n->prev->tok == n->tok &&
1168 MDOC_Ft != n->tok &&
1169 MDOC_Fo != n->tok &&
1170 MDOC_Fn != n->tok) {
1171 term_newln(p);
1172 return;
1173 }
1174
1175 /*
1176 * If we're one of the SYNOPSIS set and non-like pair-wise after
1177 * another (or Fn/Fo, which we've let slip through) then assert
1178 * vertical space, else only newline and move on.
1179 */
1180 switch (n->prev->tok) {
1181 case MDOC_Fd:
1182 case MDOC_Fn:
1183 case MDOC_Fo:
1184 case MDOC_In:
1185 case MDOC_Vt:
1186 term_vspace(p);
1187 break;
1188 case MDOC_Ft:
1189 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
1190 term_vspace(p);
1191 break;
1192 }
1193 /* FALLTHROUGH */
1194 default:
1195 term_newln(p);
1196 break;
1197 }
1198 }
1199
1200 static int
1201 termp_vt_pre(DECL_ARGS)
1202 {
1203
1204 if (n->type == ROFFT_ELEM) {
1205 synopsis_pre(p, n);
1206 return termp_under_pre(p, pair, meta, n);
1207 } else if (n->type == ROFFT_BLOCK) {
1208 synopsis_pre(p, n);
1209 return 1;
1210 } else if (n->type == ROFFT_HEAD)
1211 return 0;
1212
1213 return termp_under_pre(p, pair, meta, n);
1214 }
1215
1216 static int
1217 termp_bold_pre(DECL_ARGS)
1218 {
1219
1220 termp_tag_pre(p, pair, meta, n);
1221 term_fontpush(p, TERMFONT_BOLD);
1222 return 1;
1223 }
1224
1225 static int
1226 termp_fd_pre(DECL_ARGS)
1227 {
1228
1229 synopsis_pre(p, n);
1230 return termp_bold_pre(p, pair, meta, n);
1231 }
1232
1233 static void
1234 termp_fd_post(DECL_ARGS)
1235 {
1236
1237 term_newln(p);
1238 }
1239
1240 static int
1241 termp_sh_pre(DECL_ARGS)
1242 {
1243
1244 switch (n->type) {
1245 case ROFFT_BLOCK:
1246 /*
1247 * Vertical space before sections, except
1248 * when the previous section was empty.
1249 */
1250 if (n->prev == NULL ||
1251 n->prev->tok != MDOC_Sh ||
1252 (n->prev->body != NULL &&
1253 n->prev->body->child != NULL))
1254 term_vspace(p);
1255 break;
1256 case ROFFT_HEAD:
1257 term_fontpush(p, TERMFONT_BOLD);
1258 break;
1259 case ROFFT_BODY:
1260 p->tcol->offset = term_len(p, p->defindent);
1261 term_tab_set(p, NULL);
1262 term_tab_set(p, "T");
1263 term_tab_set(p, ".5i");
1264 switch (n->sec) {
1265 case SEC_DESCRIPTION:
1266 fn_prio = 0;
1267 break;
1268 case SEC_AUTHORS:
1269 p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);
1270 break;
1271 default:
1272 break;
1273 }
1274 break;
1275 default:
1276 break;
1277 }
1278 return 1;
1279 }
1280
1281 static void
1282 termp_sh_post(DECL_ARGS)
1283 {
1284
1285 switch (n->type) {
1286 case ROFFT_HEAD:
1287 term_newln(p);
1288 break;
1289 case ROFFT_BODY:
1290 term_newln(p);
1291 p->tcol->offset = 0;
1292 break;
1293 default:
1294 break;
1295 }
1296 }
1297
1298 static void
1299 termp_lb_post(DECL_ARGS)
1300 {
1301
1302 if (SEC_LIBRARY == n->sec && NODE_LINE & n->flags)
1303 term_newln(p);
1304 }
1305
1306 static int
1307 termp_d1_pre(DECL_ARGS)
1308 {
1309
1310 if (n->type != ROFFT_BLOCK)
1311 return 1;
1312 term_newln(p);
1313 p->tcol->offset += term_len(p, p->defindent + 1);
1314 term_tab_set(p, NULL);
1315 term_tab_set(p, "T");
1316 term_tab_set(p, ".5i");
1317 return 1;
1318 }
1319
1320 static int
1321 termp_ft_pre(DECL_ARGS)
1322 {
1323
1324 /* NB: NODE_LINE does not effect this! */
1325 synopsis_pre(p, n);
1326 term_fontpush(p, TERMFONT_UNDER);
1327 return 1;
1328 }
1329
1330 static int
1331 termp_fn_pre(DECL_ARGS)
1332 {
1333 size_t rmargin = 0;
1334 int pretty;
1335
1336 pretty = NODE_SYNPRETTY & n->flags;
1337
1338 synopsis_pre(p, n);
1339
1340 if (NULL == (n = n->child))
1341 return 0;
1342
1343 if (pretty) {
1344 rmargin = p->tcol->rmargin;
1345 p->tcol->rmargin = p->tcol->offset + term_len(p, 4);
1346 p->flags |= TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG;
1347 }
1348
1349 assert(n->type == ROFFT_TEXT);
1350 term_fontpush(p, TERMFONT_BOLD);
1351 term_word(p, n->string);
1352 term_fontpop(p);
1353
1354 if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM)
1355 tag_put(n->string, ++fn_prio, p->line);
1356
1357 if (pretty) {
1358 term_flushln(p);
1359 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND | TERMP_HANG);
1360 p->flags |= TERMP_NOPAD;
1361 p->tcol->offset = p->tcol->rmargin;
1362 p->tcol->rmargin = rmargin;
1363 }
1364
1365 p->flags |= TERMP_NOSPACE;
1366 term_word(p, "(");
1367 p->flags |= TERMP_NOSPACE;
1368
1369 for (n = n->next; n; n = n->next) {
1370 assert(n->type == ROFFT_TEXT);
1371 term_fontpush(p, TERMFONT_UNDER);
1372 if (pretty)
1373 p->flags |= TERMP_NBRWORD;
1374 term_word(p, n->string);
1375 term_fontpop(p);
1376
1377 if (n->next) {
1378 p->flags |= TERMP_NOSPACE;
1379 term_word(p, ",");
1380 }
1381 }
1382
1383 p->flags |= TERMP_NOSPACE;
1384 term_word(p, ")");
1385
1386 if (pretty) {
1387 p->flags |= TERMP_NOSPACE;
1388 term_word(p, ";");
1389 term_flushln(p);
1390 }
1391
1392 return 0;
1393 }
1394
1395 static int
1396 termp_fa_pre(DECL_ARGS)
1397 {
1398 const struct roff_node *nn;
1399
1400 if (n->parent->tok != MDOC_Fo) {
1401 term_fontpush(p, TERMFONT_UNDER);
1402 return 1;
1403 }
1404
1405 for (nn = n->child; nn; nn = nn->next) {
1406 term_fontpush(p, TERMFONT_UNDER);
1407 p->flags |= TERMP_NBRWORD;
1408 term_word(p, nn->string);
1409 term_fontpop(p);
1410
1411 if (nn->next || (n->next && n->next->tok == MDOC_Fa)) {
1412 p->flags |= TERMP_NOSPACE;
1413 term_word(p, ",");
1414 }
1415 }
1416
1417 return 0;
1418 }
1419
1420 static int
1421 termp_bd_pre(DECL_ARGS)
1422 {
1423 size_t lm, len;
1424 struct roff_node *nn;
1425 int offset;
1426
1427 if (n->type == ROFFT_BLOCK) {
1428 print_bvspace(p, n, n);
1429 return 1;
1430 } else if (n->type == ROFFT_HEAD)
1431 return 0;
1432
1433 /* Handle the -offset argument. */
1434
1435 if (n->norm->Bd.offs == NULL ||
1436 ! strcmp(n->norm->Bd.offs, "left"))
1437 /* nothing */;
1438 else if ( ! strcmp(n->norm->Bd.offs, "indent"))
1439 p->tcol->offset += term_len(p, p->defindent + 1);
1440 else if ( ! strcmp(n->norm->Bd.offs, "indent-two"))
1441 p->tcol->offset += term_len(p, (p->defindent + 1) * 2);
1442 else {
1443 offset = a2width(p, n->norm->Bd.offs);
1444 if (offset < 0 && (size_t)(-offset) > p->tcol->offset)
1445 p->tcol->offset = 0;
1446 else if (offset < SHRT_MAX)
1447 p->tcol->offset += offset;
1448 }
1449
1450 /*
1451 * If -ragged or -filled are specified, the block does nothing
1452 * but change the indentation. If -unfilled or -literal are
1453 * specified, text is printed exactly as entered in the display:
1454 * for macro lines, a newline is appended to the line. Blank
1455 * lines are allowed.
1456 */
1457
1458 if (n->norm->Bd.type != DISP_literal &&
1459 n->norm->Bd.type != DISP_unfilled &&
1460 n->norm->Bd.type != DISP_centered)
1461 return 1;
1462
1463 if (n->norm->Bd.type == DISP_literal) {
1464 term_tab_set(p, NULL);
1465 term_tab_set(p, "T");
1466 term_tab_set(p, "8n");
1467 }
1468
1469 lm = p->tcol->offset;
1470 p->flags |= TERMP_BRNEVER;
1471 for (nn = n->child; nn != NULL; nn = nn->next) {
1472 if (n->norm->Bd.type == DISP_centered) {
1473 if (nn->type == ROFFT_TEXT) {
1474 len = term_strlen(p, nn->string);
1475 p->tcol->offset = len >= p->tcol->rmargin ?
1476 0 : lm + len >= p->tcol->rmargin ?
1477 p->tcol->rmargin - len :
1478 (lm + p->tcol->rmargin - len) / 2;
1479 } else
1480 p->tcol->offset = lm;
1481 }
1482 print_mdoc_node(p, pair, meta, nn);
1483 /*
1484 * If the printed node flushes its own line, then we
1485 * needn't do it here as well. This is hacky, but the
1486 * notion of selective eoln whitespace is pretty dumb
1487 * anyway, so don't sweat it.
1488 */
1489 if (nn->tok < ROFF_MAX)
1490 continue;
1491 switch (nn->tok) {
1492 case MDOC_Sm:
1493 case MDOC_Bl:
1494 case MDOC_D1:
1495 case MDOC_Dl:
1496 case MDOC_Lp:
1497 case MDOC_Pp:
1498 continue;
1499 default:
1500 break;
1501 }
1502 if (p->flags & TERMP_NONEWLINE ||
1503 (nn->next && ! (nn->next->flags & NODE_LINE)))
1504 continue;
1505 term_flushln(p);
1506 p->flags |= TERMP_NOSPACE;
1507 }
1508 p->flags &= ~TERMP_BRNEVER;
1509 return 0;
1510 }
1511
1512 static void
1513 termp_bd_post(DECL_ARGS)
1514 {
1515 if (n->type != ROFFT_BODY)
1516 return;
1517 if (DISP_literal == n->norm->Bd.type ||
1518 DISP_unfilled == n->norm->Bd.type)
1519 p->flags |= TERMP_BRNEVER;
1520 p->flags |= TERMP_NOSPACE;
1521 term_newln(p);
1522 p->flags &= ~TERMP_BRNEVER;
1523 }
1524
1525 static int
1526 termp_xx_pre(DECL_ARGS)
1527 {
1528 if ((n->aux = p->flags & TERMP_PREKEEP) == 0)
1529 p->flags |= TERMP_PREKEEP;
1530 return 1;
1531 }
1532
1533 static void
1534 termp_xx_post(DECL_ARGS)
1535 {
1536 if (n->aux == 0)
1537 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
1538 }
1539
1540 static void
1541 termp_pf_post(DECL_ARGS)
1542 {
1543
1544 if ( ! (n->next == NULL || n->next->flags & NODE_LINE))
1545 p->flags |= TERMP_NOSPACE;
1546 }
1547
1548 static int
1549 termp_ss_pre(DECL_ARGS)
1550 {
1551 struct roff_node *nn;
1552
1553 switch (n->type) {
1554 case ROFFT_BLOCK:
1555 term_newln(p);
1556 for (nn = n->prev; nn != NULL; nn = nn->prev)
1557 if (nn->type != ROFFT_COMMENT &&
1558 (nn->flags & NODE_NOPRT) == 0)
1559 break;
1560 if (nn != NULL)
1561 term_vspace(p);
1562 break;
1563 case ROFFT_HEAD:
1564 term_fontpush(p, TERMFONT_BOLD);
1565 p->tcol->offset = term_len(p, (p->defindent+1)/2);
1566 break;
1567 case ROFFT_BODY:
1568 p->tcol->offset = term_len(p, p->defindent);
1569 term_tab_set(p, NULL);
1570 term_tab_set(p, "T");
1571 term_tab_set(p, ".5i");
1572 break;
1573 default:
1574 break;
1575 }
1576
1577 return 1;
1578 }
1579
1580 static void
1581 termp_ss_post(DECL_ARGS)
1582 {
1583
1584 if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY)
1585 term_newln(p);
1586 }
1587
1588 static int
1589 termp_cd_pre(DECL_ARGS)
1590 {
1591
1592 synopsis_pre(p, n);
1593 term_fontpush(p, TERMFONT_BOLD);
1594 return 1;
1595 }
1596
1597 static int
1598 termp_in_pre(DECL_ARGS)
1599 {
1600
1601 synopsis_pre(p, n);
1602
1603 if (NODE_SYNPRETTY & n->flags && NODE_LINE & n->flags) {
1604 term_fontpush(p, TERMFONT_BOLD);
1605 term_word(p, "#include");
1606 term_word(p, "<");
1607 } else {
1608 term_word(p, "<");
1609 term_fontpush(p, TERMFONT_UNDER);
1610 }
1611
1612 p->flags |= TERMP_NOSPACE;
1613 return 1;
1614 }
1615
1616 static void
1617 termp_in_post(DECL_ARGS)
1618 {
1619
1620 if (NODE_SYNPRETTY & n->flags)
1621 term_fontpush(p, TERMFONT_BOLD);
1622
1623 p->flags |= TERMP_NOSPACE;
1624 term_word(p, ">");
1625
1626 if (NODE_SYNPRETTY & n->flags)
1627 term_fontpop(p);
1628 }
1629
1630 static int
1631 termp_pp_pre(DECL_ARGS)
1632 {
1633 fn_prio = 0;
1634 term_vspace(p);
1635 return 0;
1636 }
1637
1638 static int
1639 termp_skip_pre(DECL_ARGS)
1640 {
1641
1642 return 0;
1643 }
1644
1645 static int
1646 termp_quote_pre(DECL_ARGS)
1647 {
1648
1649 if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM)
1650 return 1;
1651
1652 switch (n->tok) {
1653 case MDOC_Ao:
1654 case MDOC_Aq:
1655 term_word(p, n->child != NULL && n->child->next == NULL &&
1656 n->child->tok == MDOC_Mt ? "<" : "\\(la");
1657 break;
1658 case MDOC_Bro:
1659 case MDOC_Brq:
1660 term_word(p, "{");
1661 break;
1662 case MDOC_Oo:
1663 case MDOC_Op:
1664 case MDOC_Bo:
1665 case MDOC_Bq:
1666 term_word(p, "[");
1667 break;
1668 case MDOC__T:
1669 /* FALLTHROUGH */
1670 case MDOC_Do:
1671 case MDOC_Dq:
1672 term_word(p, "\\(lq");
1673 break;
1674 case MDOC_En:
1675 if (NULL == n->norm->Es ||
1676 NULL == n->norm->Es->child)
1677 return 1;
1678 term_word(p, n->norm->Es->child->string);
1679 break;
1680 case MDOC_Po:
1681 case MDOC_Pq:
1682 term_word(p, "(");
1683 break;
1684 case MDOC_Qo:
1685 case MDOC_Qq:
1686 term_word(p, "\"");
1687 break;
1688 case MDOC_Ql:
1689 case MDOC_So:
1690 case MDOC_Sq:
1691 term_word(p, "\\(oq");
1692 break;
1693 default:
1694 abort();
1695 }
1696
1697 p->flags |= TERMP_NOSPACE;
1698 return 1;
1699 }
1700
1701 static void
1702 termp_quote_post(DECL_ARGS)
1703 {
1704
1705 if (n->type != ROFFT_BODY && n->type != ROFFT_ELEM)
1706 return;
1707
1708 p->flags |= TERMP_NOSPACE;
1709
1710 switch (n->tok) {
1711 case MDOC_Ao:
1712 case MDOC_Aq:
1713 term_word(p, n->child != NULL && n->child->next == NULL &&
1714 n->child->tok == MDOC_Mt ? ">" : "\\(ra");
1715 break;
1716 case MDOC_Bro:
1717 case MDOC_Brq:
1718 term_word(p, "}");
1719 break;
1720 case MDOC_Oo:
1721 case MDOC_Op:
1722 case MDOC_Bo:
1723 case MDOC_Bq:
1724 term_word(p, "]");
1725 break;
1726 case MDOC__T:
1727 /* FALLTHROUGH */
1728 case MDOC_Do:
1729 case MDOC_Dq:
1730 term_word(p, "\\(rq");
1731 break;
1732 case MDOC_En:
1733 if (n->norm->Es == NULL ||
1734 n->norm->Es->child == NULL ||
1735 n->norm->Es->child->next == NULL)
1736 p->flags &= ~TERMP_NOSPACE;
1737 else
1738 term_word(p, n->norm->Es->child->next->string);
1739 break;
1740 case MDOC_Po:
1741 case MDOC_Pq:
1742 term_word(p, ")");
1743 break;
1744 case MDOC_Qo:
1745 case MDOC_Qq:
1746 term_word(p, "\"");
1747 break;
1748 case MDOC_Ql:
1749 case MDOC_So:
1750 case MDOC_Sq:
1751 term_word(p, "\\(cq");
1752 break;
1753 default:
1754 abort();
1755 }
1756 }
1757
1758 static int
1759 termp_eo_pre(DECL_ARGS)
1760 {
1761
1762 if (n->type != ROFFT_BODY)
1763 return 1;
1764
1765 if (n->end == ENDBODY_NOT &&
1766 n->parent->head->child == NULL &&
1767 n->child != NULL &&
1768 n->child->end != ENDBODY_NOT)
1769 term_word(p, "\\&");
1770 else if (n->end != ENDBODY_NOT ? n->child != NULL :
1771 n->parent->head->child != NULL && (n->child != NULL ||
1772 (n->parent->tail != NULL && n->parent->tail->child != NULL)))
1773 p->flags |= TERMP_NOSPACE;
1774
1775 return 1;
1776 }
1777
1778 static void
1779 termp_eo_post(DECL_ARGS)
1780 {
1781 int body, tail;
1782
1783 if (n->type != ROFFT_BODY)
1784 return;
1785
1786 if (n->end != ENDBODY_NOT) {
1787 p->flags &= ~TERMP_NOSPACE;
1788 return;
1789 }
1790
1791 body = n->child != NULL || n->parent->head->child != NULL;
1792 tail = n->parent->tail != NULL && n->parent->tail->child != NULL;
1793
1794 if (body && tail)
1795 p->flags |= TERMP_NOSPACE;
1796 else if ( ! (body || tail))
1797 term_word(p, "\\&");
1798 else if ( ! tail)
1799 p->flags &= ~TERMP_NOSPACE;
1800 }
1801
1802 static int
1803 termp_fo_pre(DECL_ARGS)
1804 {
1805 size_t rmargin = 0;
1806 int pretty;
1807
1808 pretty = NODE_SYNPRETTY & n->flags;
1809
1810 if (n->type == ROFFT_BLOCK) {
1811 synopsis_pre(p, n);
1812 return 1;
1813 } else if (n->type == ROFFT_BODY) {
1814 if (pretty) {
1815 rmargin = p->tcol->rmargin;
1816 p->tcol->rmargin = p->tcol->offset + term_len(p, 4);
1817 p->flags |= TERMP_NOBREAK | TERMP_BRIND |
1818 TERMP_HANG;
1819 }
1820 p->flags |= TERMP_NOSPACE;
1821 term_word(p, "(");
1822 p->flags |= TERMP_NOSPACE;
1823 if (pretty) {
1824 term_flushln(p);
1825 p->flags &= ~(TERMP_NOBREAK | TERMP_BRIND |
1826 TERMP_HANG);
1827 p->flags |= TERMP_NOPAD;
1828 p->tcol->offset = p->tcol->rmargin;
1829 p->tcol->rmargin = rmargin;
1830 }
1831 return 1;
1832 }
1833
1834 if (NULL == n->child)
1835 return 0;
1836
1837 /* XXX: we drop non-initial arguments as per groff. */
1838
1839 assert(n->child->string);
1840 term_fontpush(p, TERMFONT_BOLD);
1841 term_word(p, n->child->string);
1842 return 0;
1843 }
1844
1845 static void
1846 termp_fo_post(DECL_ARGS)
1847 {
1848
1849 if (n->type != ROFFT_BODY)
1850 return;
1851
1852 p->flags |= TERMP_NOSPACE;
1853 term_word(p, ")");
1854
1855 if (NODE_SYNPRETTY & n->flags) {
1856 p->flags |= TERMP_NOSPACE;
1857 term_word(p, ";");
1858 term_flushln(p);
1859 }
1860 }
1861
1862 static int
1863 termp_bf_pre(DECL_ARGS)
1864 {
1865
1866 if (n->type == ROFFT_HEAD)
1867 return 0;
1868 else if (n->type != ROFFT_BODY)
1869 return 1;
1870
1871 if (FONT_Em == n->norm->Bf.font)
1872 term_fontpush(p, TERMFONT_UNDER);
1873 else if (FONT_Sy == n->norm->Bf.font)
1874 term_fontpush(p, TERMFONT_BOLD);
1875 else
1876 term_fontpush(p, TERMFONT_NONE);
1877
1878 return 1;
1879 }
1880
1881 static int
1882 termp_sm_pre(DECL_ARGS)
1883 {
1884
1885 if (NULL == n->child)
1886 p->flags ^= TERMP_NONOSPACE;
1887 else if (0 == strcmp("on", n->child->string))
1888 p->flags &= ~TERMP_NONOSPACE;
1889 else
1890 p->flags |= TERMP_NONOSPACE;
1891
1892 if (p->col && ! (TERMP_NONOSPACE & p->flags))
1893 p->flags &= ~TERMP_NOSPACE;
1894
1895 return 0;
1896 }
1897
1898 static int
1899 termp_ap_pre(DECL_ARGS)
1900 {
1901
1902 p->flags |= TERMP_NOSPACE;
1903 term_word(p, "'");
1904 p->flags |= TERMP_NOSPACE;
1905 return 1;
1906 }
1907
1908 static void
1909 termp____post(DECL_ARGS)
1910 {
1911
1912 /*
1913 * Handle lists of authors. In general, print each followed by
1914 * a comma. Don't print the comma if there are only two
1915 * authors.
1916 */
1917 if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)
1918 if (NULL == n->next->next || MDOC__A != n->next->next->tok)
1919 if (NULL == n->prev || MDOC__A != n->prev->tok)
1920 return;
1921
1922 /* TODO: %U. */
1923
1924 if (NULL == n->parent || MDOC_Rs != n->parent->tok)
1925 return;
1926
1927 p->flags |= TERMP_NOSPACE;
1928 if (NULL == n->next) {
1929 term_word(p, ".");
1930 p->flags |= TERMP_SENTENCE;
1931 } else
1932 term_word(p, ",");
1933 }
1934
1935 static int
1936 termp_li_pre(DECL_ARGS)
1937 {
1938
1939 termp_tag_pre(p, pair, meta, n);
1940 term_fontpush(p, TERMFONT_NONE);
1941 return 1;
1942 }
1943
1944 static int
1945 termp_lk_pre(DECL_ARGS)
1946 {
1947 const struct roff_node *link, *descr, *punct;
1948
1949 if ((link = n->child) == NULL)
1950 return 0;
1951
1952 /* Find beginning of trailing punctuation. */
1953 punct = n->last;
1954 while (punct != link && punct->flags & NODE_DELIMC)
1955 punct = punct->prev;
1956 punct = punct->next;
1957
1958 /* Link text. */
1959 if ((descr = link->next) != NULL && descr != punct) {
1960 term_fontpush(p, TERMFONT_UNDER);
1961 while (descr != punct) {
1962 if (descr->flags & (NODE_DELIMC | NODE_DELIMO))
1963 p->flags |= TERMP_NOSPACE;
1964 term_word(p, descr->string);
1965 descr = descr->next;
1966 }
1967 term_fontpop(p);
1968 p->flags |= TERMP_NOSPACE;
1969 term_word(p, ":");
1970 }
1971
1972 /* Link target. */
1973 term_fontpush(p, TERMFONT_BOLD);
1974 term_word(p, link->string);
1975 term_fontpop(p);
1976
1977 /* Trailing punctuation. */
1978 while (punct != NULL) {
1979 p->flags |= TERMP_NOSPACE;
1980 term_word(p, punct->string);
1981 punct = punct->next;
1982 }
1983 return 0;
1984 }
1985
1986 static int
1987 termp_bk_pre(DECL_ARGS)
1988 {
1989
1990 switch (n->type) {
1991 case ROFFT_BLOCK:
1992 break;
1993 case ROFFT_HEAD:
1994 return 0;
1995 case ROFFT_BODY:
1996 if (n->parent->args != NULL || n->prev->child == NULL)
1997 p->flags |= TERMP_PREKEEP;
1998 break;
1999 default:
2000 abort();
2001 }
2002
2003 return 1;
2004 }
2005
2006 static void
2007 termp_bk_post(DECL_ARGS)
2008 {
2009
2010 if (n->type == ROFFT_BODY)
2011 p->flags &= ~(TERMP_KEEP | TERMP_PREKEEP);
2012 }
2013
2014 static void
2015 termp__t_post(DECL_ARGS)
2016 {
2017
2018 /*
2019 * If we're in an `Rs' and there's a journal present, then quote
2020 * us instead of underlining us (for disambiguation).
2021 */
2022 if (n->parent && MDOC_Rs == n->parent->tok &&
2023 n->parent->norm->Rs.quote_T)
2024 termp_quote_post(p, pair, meta, n);
2025
2026 termp____post(p, pair, meta, n);
2027 }
2028
2029 static int
2030 termp__t_pre(DECL_ARGS)
2031 {
2032
2033 /*
2034 * If we're in an `Rs' and there's a journal present, then quote
2035 * us instead of underlining us (for disambiguation).
2036 */
2037 if (n->parent && MDOC_Rs == n->parent->tok &&
2038 n->parent->norm->Rs.quote_T)
2039 return termp_quote_pre(p, pair, meta, n);
2040
2041 term_fontpush(p, TERMFONT_UNDER);
2042 return 1;
2043 }
2044
2045 static int
2046 termp_under_pre(DECL_ARGS)
2047 {
2048
2049 term_fontpush(p, TERMFONT_UNDER);
2050 return 1;
2051 }
2052
2053 static int
2054 termp_em_pre(DECL_ARGS)
2055 {
2056 if (n->child != NULL &&
2057 n->child->type == ROFFT_TEXT)
2058 tag_put(n->child->string, 0, p->line);
2059 term_fontpush(p, TERMFONT_UNDER);
2060 return 1;
2061 }
2062
2063 static int
2064 termp_sy_pre(DECL_ARGS)
2065 {
2066 if (n->child != NULL &&
2067 n->child->type == ROFFT_TEXT)
2068 tag_put(n->child->string, 0, p->line);
2069 term_fontpush(p, TERMFONT_BOLD);
2070 return 1;
2071 }
2072
2073 static int
2074 termp_er_pre(DECL_ARGS)
2075 {
2076
2077 if (n->sec == SEC_ERRORS &&
2078 (n->parent->tok == MDOC_It ||
2079 (n->parent->tok == MDOC_Bq &&
2080 n->parent->parent->parent->tok == MDOC_It)))
2081 tag_put(n->child->string, 1, p->line);
2082 return 1;
2083 }
2084
2085 static int
2086 termp_tag_pre(DECL_ARGS)
2087 {
2088
2089 if (n->child != NULL &&
2090 n->child->type == ROFFT_TEXT &&
2091 (n->prev == NULL ||
2092 (n->prev->type == ROFFT_TEXT &&
2093 strcmp(n->prev->string, "|") == 0)) &&
2094 (n->parent->tok == MDOC_It ||
2095 (n->parent->tok == MDOC_Xo &&
2096 n->parent->parent->prev == NULL &&
2097 n->parent->parent->parent->tok == MDOC_It)))
2098 tag_put(n->child->string, 1, p->line);
2099 return 1;
2100 }
A git conversion mirror of mandoc.bsd.lv