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