Annotation of mandoc/mdoc_term.c, Revision 1.16
1.16 ! kristaps 1: /* $Id: mdoc_term.c,v 1.15 2009/06/17 18:42:42 kristaps Exp $ */
1.1 kristaps 2: /*
1.7 kristaps 3: * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
1.1 kristaps 4: *
5: * Permission to use, copy, modify, and distribute this software for any
1.6 kristaps 6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
1.1 kristaps 8: *
1.6 kristaps 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1 kristaps 16: */
17: #include <sys/types.h>
18:
19: #include <assert.h>
20: #include <ctype.h>
21: #include <err.h>
22: #include <stdio.h>
23: #include <stdlib.h>
24: #include <string.h>
25:
26: #include "term.h"
27: #include "mdoc.h"
28:
29: /* FIXME: macro arguments can be escaped. */
30: /* FIXME: support more offset/width tokens. */
31:
32: #define TTYPE_PROG 0
33: #define TTYPE_CMD_FLAG 1
34: #define TTYPE_CMD_ARG 2
35: #define TTYPE_SECTION 3
36: #define TTYPE_FUNC_DECL 4
37: #define TTYPE_VAR_DECL 5
38: #define TTYPE_FUNC_TYPE 6
39: #define TTYPE_FUNC_NAME 7
40: #define TTYPE_FUNC_ARG 8
41: #define TTYPE_LINK 9
42: #define TTYPE_SSECTION 10
43: #define TTYPE_FILE 11
44: #define TTYPE_EMPH 12
45: #define TTYPE_CONFIG 13
46: #define TTYPE_CMD 14
47: #define TTYPE_INCLUDE 15
48: #define TTYPE_SYMB 16
49: #define TTYPE_SYMBOL 17
50: #define TTYPE_DIAG 18
51: #define TTYPE_LINK_ANCHOR 19
52: #define TTYPE_LINK_TEXT 20
53: #define TTYPE_REF_JOURNAL 21
54: #define TTYPE_LIST 22
55: #define TTYPE_NMAX 23
56:
57: const int ttypes[TTYPE_NMAX] = {
58: TERMP_BOLD, /* TTYPE_PROG */
59: TERMP_BOLD, /* TTYPE_CMD_FLAG */
60: TERMP_UNDER, /* TTYPE_CMD_ARG */
61: TERMP_BOLD, /* TTYPE_SECTION */
62: TERMP_BOLD, /* TTYPE_FUNC_DECL */
63: TERMP_UNDER, /* TTYPE_VAR_DECL */
64: TERMP_UNDER, /* TTYPE_FUNC_TYPE */
65: TERMP_BOLD, /* TTYPE_FUNC_NAME */
66: TERMP_UNDER, /* TTYPE_FUNC_ARG */
67: TERMP_UNDER, /* TTYPE_LINK */
68: TERMP_BOLD, /* TTYPE_SSECTION */
69: TERMP_UNDER, /* TTYPE_FILE */
70: TERMP_UNDER, /* TTYPE_EMPH */
71: TERMP_BOLD, /* TTYPE_CONFIG */
72: TERMP_BOLD, /* TTYPE_CMD */
73: TERMP_BOLD, /* TTYPE_INCLUDE */
74: TERMP_BOLD, /* TTYPE_SYMB */
75: TERMP_BOLD, /* TTYPE_SYMBOL */
76: TERMP_BOLD, /* TTYPE_DIAG */
77: TERMP_UNDER, /* TTYPE_LINK_ANCHOR */
78: TERMP_BOLD, /* TTYPE_LINK_TEXT */
79: TERMP_UNDER, /* TTYPE_REF_JOURNAL */
80: TERMP_BOLD /* TTYPE_LIST */
81: };
82:
83: /* XXX - clean this up. */
84:
85: struct termpair {
86: struct termpair *ppair;
87: int type;
88: #define TERMPAIR_FLAG (1 << 0)
1.10 kristaps 89: int flag; /* Whether being used. */
90: size_t offset; /* Left margin. */
91: size_t rmargin; /* Right margin. */
92: int count; /* Enum count. */
1.1 kristaps 93: };
94:
95: #define TERMPAIR_SETFLAG(termp, p, fl) \
96: do { \
97: assert(! (TERMPAIR_FLAG & (p)->type)); \
98: (termp)->flags |= (fl); \
99: (p)->flag = (fl); \
100: (p)->type |= TERMPAIR_FLAG; \
101: } while ( /* CONSTCOND */ 0)
102:
103: #define DECL_ARGS \
104: struct termp *p, struct termpair *pair, \
105: const struct mdoc_meta *meta, \
106: const struct mdoc_node *node
107:
108: #define DECL_PRE(name) \
109: static int name##_pre(DECL_ARGS)
110: #define DECL_POST(name) \
111: static void name##_post(DECL_ARGS)
112: #define DECL_PREPOST(name) \
113: DECL_PRE(name); \
114: DECL_POST(name);
115:
116: DECL_PREPOST(termp__t);
117: DECL_PREPOST(termp_aq);
118: DECL_PREPOST(termp_bd);
119: DECL_PREPOST(termp_bq);
120: DECL_PREPOST(termp_brq);
121: DECL_PREPOST(termp_d1);
122: DECL_PREPOST(termp_dq);
123: DECL_PREPOST(termp_fd);
124: DECL_PREPOST(termp_fn);
125: DECL_PREPOST(termp_fo);
126: DECL_PREPOST(termp_ft);
127: DECL_PREPOST(termp_in);
128: DECL_PREPOST(termp_it);
129: DECL_PREPOST(termp_lb);
130: DECL_PREPOST(termp_op);
131: DECL_PREPOST(termp_pf);
132: DECL_PREPOST(termp_pq);
133: DECL_PREPOST(termp_qq);
134: DECL_PREPOST(termp_sh);
135: DECL_PREPOST(termp_ss);
136: DECL_PREPOST(termp_sq);
137: DECL_PREPOST(termp_vt);
138:
139: DECL_PRE(termp__j);
140: DECL_PRE(termp_ap);
141: DECL_PRE(termp_ar);
142: DECL_PRE(termp_at);
143: DECL_PRE(termp_bf);
144: DECL_PRE(termp_bsx);
145: DECL_PRE(termp_bt);
146: DECL_PRE(termp_cd);
147: DECL_PRE(termp_cm);
148: DECL_PRE(termp_dx);
149: DECL_PRE(termp_em);
150: DECL_PRE(termp_ex);
151: DECL_PRE(termp_fa);
152: DECL_PRE(termp_fl);
153: DECL_PRE(termp_fx);
154: DECL_PRE(termp_ic);
155: DECL_PRE(termp_lk);
156: DECL_PRE(termp_ms);
157: DECL_PRE(termp_mt);
158: DECL_PRE(termp_nd);
159: DECL_PRE(termp_nm);
160: DECL_PRE(termp_ns);
161: DECL_PRE(termp_nx);
162: DECL_PRE(termp_ox);
163: DECL_PRE(termp_pa);
164: DECL_PRE(termp_pp);
165: DECL_PRE(termp_rs);
166: DECL_PRE(termp_rv);
167: DECL_PRE(termp_sm);
168: DECL_PRE(termp_st);
169: DECL_PRE(termp_sx);
170: DECL_PRE(termp_sy);
171: DECL_PRE(termp_ud);
172: DECL_PRE(termp_ux);
173: DECL_PRE(termp_va);
174: DECL_PRE(termp_xr);
175:
176: DECL_POST(termp___);
177: DECL_POST(termp_bl);
178: DECL_POST(termp_bx);
179:
180: struct termact {
181: int (*pre)(DECL_ARGS);
182: void (*post)(DECL_ARGS);
183: };
184:
185: static const struct termact termacts[MDOC_MAX] = {
1.14 kristaps 186: { termp_ap_pre, NULL }, /* Ap */
1.1 kristaps 187: { NULL, NULL }, /* Dd */
188: { NULL, NULL }, /* Dt */
189: { NULL, NULL }, /* Os */
190: { termp_sh_pre, termp_sh_post }, /* Sh */
191: { termp_ss_pre, termp_ss_post }, /* Ss */
192: { termp_pp_pre, NULL }, /* Pp */
193: { termp_d1_pre, termp_d1_post }, /* D1 */
194: { termp_d1_pre, termp_d1_post }, /* Dl */
195: { termp_bd_pre, termp_bd_post }, /* Bd */
196: { NULL, NULL }, /* Ed */
197: { NULL, termp_bl_post }, /* Bl */
198: { NULL, NULL }, /* El */
199: { termp_it_pre, termp_it_post }, /* It */
200: { NULL, NULL }, /* Ad */
201: { NULL, NULL }, /* An */
202: { termp_ar_pre, NULL }, /* Ar */
203: { termp_cd_pre, NULL }, /* Cd */
204: { termp_cm_pre, NULL }, /* Cm */
205: { NULL, NULL }, /* Dv */
206: { NULL, NULL }, /* Er */
207: { NULL, NULL }, /* Ev */
208: { termp_ex_pre, NULL }, /* Ex */
209: { termp_fa_pre, NULL }, /* Fa */
210: { termp_fd_pre, termp_fd_post }, /* Fd */
211: { termp_fl_pre, NULL }, /* Fl */
212: { termp_fn_pre, termp_fn_post }, /* Fn */
213: { termp_ft_pre, termp_ft_post }, /* Ft */
214: { termp_ic_pre, NULL }, /* Ic */
215: { termp_in_pre, termp_in_post }, /* In */
216: { NULL, NULL }, /* Li */
217: { termp_nd_pre, NULL }, /* Nd */
218: { termp_nm_pre, NULL }, /* Nm */
219: { termp_op_pre, termp_op_post }, /* Op */
220: { NULL, NULL }, /* Ot */
221: { termp_pa_pre, NULL }, /* Pa */
222: { termp_rv_pre, NULL }, /* Rv */
223: { termp_st_pre, NULL }, /* St */
224: { termp_va_pre, NULL }, /* Va */
225: { termp_vt_pre, termp_vt_post }, /* Vt */
226: { termp_xr_pre, NULL }, /* Xr */
227: { NULL, termp____post }, /* %A */
228: { NULL, termp____post }, /* %B */
229: { NULL, termp____post }, /* %D */
230: { NULL, termp____post }, /* %I */
231: { termp__j_pre, termp____post }, /* %J */
232: { NULL, termp____post }, /* %N */
233: { NULL, termp____post }, /* %O */
234: { NULL, termp____post }, /* %P */
235: { NULL, termp____post }, /* %R */
236: { termp__t_pre, termp__t_post }, /* %T */
237: { NULL, termp____post }, /* %V */
238: { NULL, NULL }, /* Ac */
239: { termp_aq_pre, termp_aq_post }, /* Ao */
240: { termp_aq_pre, termp_aq_post }, /* Aq */
241: { termp_at_pre, NULL }, /* At */
242: { NULL, NULL }, /* Bc */
243: { termp_bf_pre, NULL }, /* Bf */
244: { termp_bq_pre, termp_bq_post }, /* Bo */
245: { termp_bq_pre, termp_bq_post }, /* Bq */
246: { termp_bsx_pre, NULL }, /* Bsx */
247: { NULL, termp_bx_post }, /* Bx */
248: { NULL, NULL }, /* Db */
249: { NULL, NULL }, /* Dc */
250: { termp_dq_pre, termp_dq_post }, /* Do */
251: { termp_dq_pre, termp_dq_post }, /* Dq */
252: { NULL, NULL }, /* Ec */
253: { NULL, NULL }, /* Ef */
254: { termp_em_pre, NULL }, /* Em */
255: { NULL, NULL }, /* Eo */
256: { termp_fx_pre, NULL }, /* Fx */
257: { termp_ms_pre, NULL }, /* Ms */
258: { NULL, NULL }, /* No */
259: { termp_ns_pre, NULL }, /* Ns */
260: { termp_nx_pre, NULL }, /* Nx */
261: { termp_ox_pre, NULL }, /* Ox */
262: { NULL, NULL }, /* Pc */
263: { termp_pf_pre, termp_pf_post }, /* Pf */
264: { termp_pq_pre, termp_pq_post }, /* Po */
265: { termp_pq_pre, termp_pq_post }, /* Pq */
266: { NULL, NULL }, /* Qc */
267: { termp_sq_pre, termp_sq_post }, /* Ql */
268: { termp_qq_pre, termp_qq_post }, /* Qo */
269: { termp_qq_pre, termp_qq_post }, /* Qq */
270: { NULL, NULL }, /* Re */
271: { termp_rs_pre, NULL }, /* Rs */
272: { NULL, NULL }, /* Sc */
273: { termp_sq_pre, termp_sq_post }, /* So */
274: { termp_sq_pre, termp_sq_post }, /* Sq */
275: { termp_sm_pre, NULL }, /* Sm */
276: { termp_sx_pre, NULL }, /* Sx */
277: { termp_sy_pre, NULL }, /* Sy */
278: { NULL, NULL }, /* Tn */
279: { termp_ux_pre, NULL }, /* Ux */
280: { NULL, NULL }, /* Xc */
281: { NULL, NULL }, /* Xo */
282: { termp_fo_pre, termp_fo_post }, /* Fo */
283: { NULL, NULL }, /* Fc */
284: { termp_op_pre, termp_op_post }, /* Oo */
285: { NULL, NULL }, /* Oc */
286: { NULL, NULL }, /* Bk */
287: { NULL, NULL }, /* Ek */
288: { termp_bt_pre, NULL }, /* Bt */
289: { NULL, NULL }, /* Hf */
290: { NULL, NULL }, /* Fr */
291: { termp_ud_pre, NULL }, /* Ud */
292: { termp_lb_pre, termp_lb_post }, /* Lb */
1.14 kristaps 293: { termp_pp_pre, NULL }, /* Lp */
1.1 kristaps 294: { termp_lk_pre, NULL }, /* Lk */
295: { termp_mt_pre, NULL }, /* Mt */
296: { termp_brq_pre, termp_brq_post }, /* Brq */
297: { termp_brq_pre, termp_brq_post }, /* Bro */
298: { NULL, NULL }, /* Brc */
299: { NULL, NULL }, /* %C */
300: { NULL, NULL }, /* Es */
301: { NULL, NULL }, /* En */
302: { termp_dx_pre, NULL }, /* Dx */
303: { NULL, NULL }, /* %Q */
304: };
305:
1.2 kristaps 306: #ifdef __linux__
1.9 kristaps 307: extern size_t strlcpy(char *, const char *, size_t);
308: extern size_t strlcat(char *, const char *, size_t);
1.2 kristaps 309: #endif
310:
1.1 kristaps 311: static int arg_hasattr(int, const struct mdoc_node *);
312: static int arg_getattrs(const int *, int *, size_t,
313: const struct mdoc_node *);
314: static int arg_getattr(int, const struct mdoc_node *);
315: static size_t arg_offset(const struct mdoc_argv *);
316: static size_t arg_width(const struct mdoc_argv *, int);
317: static int arg_listtype(const struct mdoc_node *);
318: static int fmt_block_vspace(struct termp *,
319: const struct mdoc_node *,
320: const struct mdoc_node *);
1.3 kristaps 321: static void print_node(DECL_ARGS);
322: static void print_head(struct termp *,
1.1 kristaps 323: const struct mdoc_meta *);
1.3 kristaps 324: static void print_body(DECL_ARGS);
325: static void print_foot(struct termp *,
1.1 kristaps 326: const struct mdoc_meta *);
327:
328:
329: int
330: mdoc_run(struct termp *p, const struct mdoc *m)
331: {
1.9 kristaps 332: /*
333: * Main output function. When this is called, assume that the
334: * tree is properly formed.
335: */
1.1 kristaps 336:
1.3 kristaps 337: print_head(p, mdoc_meta(m));
1.14 kristaps 338: assert(mdoc_node(m));
339: assert(MDOC_ROOT == mdoc_node(m)->type);
340: if (mdoc_node(m)->child)
341: print_body(p, NULL, mdoc_meta(m), mdoc_node(m)->child);
1.3 kristaps 342: print_foot(p, mdoc_meta(m));
343: return(1);
1.1 kristaps 344: }
345:
346:
1.3 kristaps 347: static void
1.1 kristaps 348: print_body(DECL_ARGS)
349: {
350:
1.3 kristaps 351: print_node(p, pair, meta, node);
1.1 kristaps 352: if ( ! node->next)
1.3 kristaps 353: return;
354: print_body(p, pair, meta, node->next);
1.1 kristaps 355: }
356:
357:
1.3 kristaps 358: static void
1.1 kristaps 359: print_node(DECL_ARGS)
360: {
361: int dochild;
362: struct termpair npair;
363:
364: /* Pre-processing. */
365:
366: dochild = 1;
367: npair.ppair = pair;
368: npair.type = 0;
369: npair.offset = npair.rmargin = 0;
370: npair.flag = 0;
371: npair.count = 0;
372:
373: if (MDOC_TEXT != node->type) {
374: if (termacts[node->tok].pre)
375: if ( ! (*termacts[node->tok].pre)(p, &npair, meta, node))
376: dochild = 0;
377: } else /* MDOC_TEXT == node->type */
378: term_word(p, node->string);
379:
380: /* Children. */
381:
382: if (TERMPAIR_FLAG & npair.type)
383: p->flags |= npair.flag;
384:
385: if (dochild && node->child)
386: print_body(p, &npair, meta, node->child);
387:
388: if (TERMPAIR_FLAG & npair.type)
389: p->flags &= ~npair.flag;
390:
391: /* Post-processing. */
392:
393: if (MDOC_TEXT != node->type)
394: if (termacts[node->tok].post)
395: (*termacts[node->tok].post)(p, &npair, meta, node);
396: }
397:
398:
1.3 kristaps 399: static void
1.1 kristaps 400: print_foot(struct termp *p, const struct mdoc_meta *meta)
401: {
402: struct tm *tm;
403: char *buf, *os;
404:
1.9 kristaps 405: /*
406: * Output the footer in new-groff style, that is, three columns
407: * with the middle being the manual date and flanking columns
408: * being the operating system:
409: *
410: * SYSTEM DATE SYSTEM
411: */
412:
1.1 kristaps 413: if (NULL == (buf = malloc(p->rmargin)))
414: err(1, "malloc");
415: if (NULL == (os = malloc(p->rmargin)))
416: err(1, "malloc");
417:
418: tm = localtime(&meta->date);
419:
420: if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm))
421: err(1, "strftime");
422:
423: (void)strlcpy(os, meta->os, p->rmargin);
424:
425: term_vspace(p);
426:
1.9 kristaps 427: p->offset = 0;
428: p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
1.1 kristaps 429: p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
430:
431: term_word(p, os);
432: term_flushln(p);
433:
1.9 kristaps 434: p->offset = p->rmargin;
435: p->rmargin = p->maxrmargin - strlen(os);
1.1 kristaps 436: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1.9 kristaps 437:
438: term_word(p, buf);
439: term_flushln(p);
440:
1.1 kristaps 441: p->offset = p->rmargin;
442: p->rmargin = p->maxrmargin;
443: p->flags &= ~TERMP_NOBREAK;
1.9 kristaps 444: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1.1 kristaps 445:
1.9 kristaps 446: term_word(p, os);
1.1 kristaps 447: term_flushln(p);
448:
1.9 kristaps 449: p->offset = 0;
450: p->rmargin = p->maxrmargin;
451: p->flags = 0;
452:
1.1 kristaps 453: free(buf);
454: free(os);
455: }
456:
457:
1.3 kristaps 458: static void
1.1 kristaps 459: print_head(struct termp *p, const struct mdoc_meta *meta)
460: {
461: char *buf, *title;
462:
463: p->rmargin = p->maxrmargin;
464: p->offset = 0;
465:
466: if (NULL == (buf = malloc(p->rmargin)))
467: err(1, "malloc");
468: if (NULL == (title = malloc(p->rmargin)))
469: err(1, "malloc");
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: (void)strlcpy(buf, meta->vol, p->rmargin);
486:
487: if (meta->arch) {
488: (void)strlcat(buf, " (", p->rmargin);
489: (void)strlcat(buf, meta->arch, p->rmargin);
490: (void)strlcat(buf, ")", p->rmargin);
491: }
492:
493: (void)snprintf(title, p->rmargin, "%s(%d)",
494: meta->title, meta->msec);
495:
496: p->offset = 0;
1.8 kristaps 497: p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
1.1 kristaps 498: p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
499:
500: term_word(p, title);
501: term_flushln(p);
502:
503: p->offset = p->rmargin;
504: p->rmargin = p->maxrmargin - strlen(title);
1.9 kristaps 505: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1.1 kristaps 506:
507: term_word(p, buf);
508: term_flushln(p);
509:
510: p->offset = p->rmargin;
511: p->rmargin = p->maxrmargin;
512: p->flags &= ~TERMP_NOBREAK;
513: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
514:
515: term_word(p, title);
516: term_flushln(p);
517:
1.9 kristaps 518: p->offset = 0;
1.1 kristaps 519: p->rmargin = p->maxrmargin;
520: p->flags &= ~TERMP_NOSPACE;
521:
522: free(title);
523: free(buf);
524: }
525:
526:
527: static size_t
528: arg_width(const struct mdoc_argv *arg, int pos)
529: {
530: size_t v;
531: int i, len;
532:
533: assert(pos < (int)arg->sz && pos >= 0);
534: assert(arg->value[pos]);
535: if (0 == strcmp(arg->value[pos], "indent"))
1.16 ! kristaps 536: return(INDENT + 3);
1.1 kristaps 537: if (0 == strcmp(arg->value[pos], "indent-two"))
1.16 ! kristaps 538: return(INDENT * 2 + 2);
1.1 kristaps 539:
540: if (0 == (len = (int)strlen(arg->value[pos])))
541: return(0);
542:
543: for (i = 0; i < len - 1; i++)
544: if ( ! isdigit((u_char)arg->value[pos][i]))
545: break;
546:
547: if (i == len - 1) {
1.16 ! kristaps 548: if ('n' == arg->value[pos][len - 1] ||
! 549: 'm' == arg->value[pos][len - 1]) {
1.1 kristaps 550: v = (size_t)atoi(arg->value[pos]);
1.16 ! kristaps 551: return(v + 2);
1.1 kristaps 552: }
553:
554: }
1.16 ! kristaps 555: return(strlen(arg->value[pos]) + 2);
1.1 kristaps 556: }
557:
558:
559: static int
560: arg_listtype(const struct mdoc_node *n)
561: {
562: int i, len;
563:
564: assert(MDOC_BLOCK == n->type);
565:
566: len = (int)(n->args ? n->args->argc : 0);
567:
568: for (i = 0; i < len; i++)
569: switch (n->args->argv[i].arg) {
570: case (MDOC_Bullet):
571: /* FALLTHROUGH */
572: case (MDOC_Dash):
573: /* FALLTHROUGH */
574: case (MDOC_Enum):
575: /* FALLTHROUGH */
576: case (MDOC_Hyphen):
577: /* FALLTHROUGH */
578: case (MDOC_Tag):
579: /* FALLTHROUGH */
580: case (MDOC_Inset):
581: /* FALLTHROUGH */
582: case (MDOC_Diag):
583: /* FALLTHROUGH */
584: case (MDOC_Item):
585: /* FALLTHROUGH */
586: case (MDOC_Column):
587: /* FALLTHROUGH */
588: case (MDOC_Ohang):
589: return(n->args->argv[i].arg);
590: default:
591: break;
592: }
593:
1.11 kristaps 594: /* FIXME: mandated by parser. */
595:
1.1 kristaps 596: errx(1, "list type not supported");
597: /* NOTREACHED */
598: }
599:
600:
601: static size_t
602: arg_offset(const struct mdoc_argv *arg)
603: {
604:
605: assert(*arg->value);
1.10 kristaps 606: if (0 == strcmp(*arg->value, "left"))
1.16 ! kristaps 607: return(INDENT - 1);
1.1 kristaps 608: if (0 == strcmp(*arg->value, "indent"))
1.16 ! kristaps 609: return(INDENT + 1);
1.1 kristaps 610: if (0 == strcmp(*arg->value, "indent-two"))
611: return(INDENT * 2);
1.10 kristaps 612:
613: /* FIXME: needs to support field-widths (10n, etc.). */
1.11 kristaps 614:
1.1 kristaps 615: return(strlen(*arg->value));
616: }
617:
618:
619: static int
620: arg_hasattr(int arg, const struct mdoc_node *n)
621: {
622:
623: return(-1 != arg_getattr(arg, n));
624: }
625:
626:
627: static int
628: arg_getattr(int v, const struct mdoc_node *n)
629: {
630: int val;
631:
632: return(arg_getattrs(&v, &val, 1, n) ? val : -1);
633: }
634:
635:
636: static int
637: arg_getattrs(const int *keys, int *vals,
638: size_t sz, const struct mdoc_node *n)
639: {
640: int i, j, k;
641:
642: if (NULL == n->args)
643: return(0);
644:
645: for (k = i = 0; i < (int)n->args->argc; i++)
646: for (j = 0; j < (int)sz; j++)
647: if (n->args->argv[i].arg == keys[j]) {
648: vals[j] = i;
649: k++;
650: }
651: return(k);
652: }
653:
654:
655: /* ARGSUSED */
656: static int
657: fmt_block_vspace(struct termp *p,
658: const struct mdoc_node *bl,
659: const struct mdoc_node *node)
660: {
661: const struct mdoc_node *n;
662:
663: term_newln(p);
664:
665: if (arg_hasattr(MDOC_Compact, bl))
666: return(1);
667:
668: for (n = node; n; n = n->parent) {
669: if (MDOC_BLOCK != n->type)
670: continue;
671: if (MDOC_Ss == n->tok)
672: break;
673: if (MDOC_Sh == n->tok)
674: break;
675: if (NULL == n->prev)
676: continue;
677: term_vspace(p);
678: break;
679: }
680:
681: return(1);
682: }
683:
684:
685: /* ARGSUSED */
686: static int
687: termp_dq_pre(DECL_ARGS)
688: {
689:
690: if (MDOC_BODY != node->type)
691: return(1);
692:
693: term_word(p, "\\(lq");
694: p->flags |= TERMP_NOSPACE;
695: return(1);
696: }
697:
698:
699: /* ARGSUSED */
700: static void
701: termp_dq_post(DECL_ARGS)
702: {
703:
704: if (MDOC_BODY != node->type)
705: return;
706:
707: p->flags |= TERMP_NOSPACE;
708: term_word(p, "\\(rq");
709: }
710:
711:
712: /* ARGSUSED */
713: static int
714: termp_it_pre(DECL_ARGS)
715: {
716: const struct mdoc_node *bl, *n;
717: char buf[7];
1.15 kristaps 718: int i, type, keys[3], vals[3], sv;
1.1 kristaps 719: size_t width, offset;
720:
721: if (MDOC_BLOCK == node->type)
722: return(fmt_block_vspace(p, node->parent->parent, node));
723:
724: bl = node->parent->parent->parent;
725:
726: /* Save parent attributes. */
727:
728: pair->offset = p->offset;
729: pair->rmargin = p->rmargin;
730: pair->flag = p->flags;
731:
732: /* Get list width and offset. */
733:
734: keys[0] = MDOC_Width;
735: keys[1] = MDOC_Offset;
736: keys[2] = MDOC_Column;
737:
738: vals[0] = vals[1] = vals[2] = -1;
739:
740: width = offset = 0;
741:
742: (void)arg_getattrs(keys, vals, 3, bl);
743:
744: type = arg_listtype(bl);
745:
746: /* Calculate real width and offset. */
747:
748: switch (type) {
749: case (MDOC_Column):
750: if (MDOC_BODY == node->type)
751: break;
752: for (i = 0, n = node->prev; n; n = n->prev, i++)
753: offset += arg_width
754: (&bl->args->argv[vals[2]], i);
755: assert(i < (int)bl->args->argv[vals[2]].sz);
756: width = arg_width(&bl->args->argv[vals[2]], i);
757: if (vals[1] >= 0)
758: offset += arg_offset(&bl->args->argv[vals[1]]);
759: break;
760: default:
761: if (vals[0] >= 0)
762: width = arg_width(&bl->args->argv[vals[0]], 0);
763: if (vals[1] >= 0)
764: offset = arg_offset(&bl->args->argv[vals[1]]);
765: break;
766: }
767:
768: /*
769: * List-type can override the width in the case of fixed-head
770: * values (bullet, dash/hyphen, enum). Tags need a non-zero
771: * offset.
772: */
773:
774: switch (type) {
775: case (MDOC_Bullet):
776: /* FALLTHROUGH */
777: case (MDOC_Dash):
778: /* FALLTHROUGH */
779: case (MDOC_Enum):
780: /* FALLTHROUGH */
781: case (MDOC_Hyphen):
782: if (width < 4)
783: width = 4;
784: break;
785: case (MDOC_Tag):
786: if (0 == width)
787: width = 10;
788: break;
789: default:
790: break;
791: }
792:
793: /*
794: * Whitespace control. Inset bodies need an initial space.
795: */
796:
797: switch (type) {
798: case (MDOC_Diag):
799: /* FALLTHROUGH */
800: case (MDOC_Inset):
801: if (MDOC_BODY == node->type)
802: p->flags &= ~TERMP_NOSPACE;
803: else
804: p->flags |= TERMP_NOSPACE;
805: break;
806: default:
807: p->flags |= TERMP_NOSPACE;
808: break;
809: }
810:
811: /*
812: * Style flags. Diagnostic heads need TTYPE_DIAG.
813: */
814:
815: switch (type) {
816: case (MDOC_Diag):
817: if (MDOC_HEAD == node->type)
818: p->flags |= ttypes[TTYPE_DIAG];
819: break;
820: default:
821: break;
822: }
823:
824: /*
825: * Pad and break control. This is the tricker part. Lists with
826: * set right-margins for the head get TERMP_NOBREAK because, if
827: * they overrun the margin, they wrap to the new margin.
828: * Correspondingly, the body for these types don't left-pad, as
829: * the head will pad out to to the right.
830: */
831:
832: switch (type) {
833: case (MDOC_Bullet):
834: /* FALLTHROUGH */
835: case (MDOC_Dash):
836: /* FALLTHROUGH */
837: case (MDOC_Enum):
838: /* FALLTHROUGH */
839: case (MDOC_Hyphen):
840: /* FALLTHROUGH */
841: case (MDOC_Tag):
842: if (MDOC_HEAD == node->type)
843: p->flags |= TERMP_NOBREAK;
844: else
845: p->flags |= TERMP_NOLPAD;
846: if (MDOC_HEAD == node->type && MDOC_Tag == type)
847: if (NULL == node->next ||
848: NULL == node->next->child)
849: p->flags |= TERMP_NONOBREAK;
850: break;
851: case (MDOC_Column):
852: if (MDOC_HEAD == node->type) {
853: assert(node->next);
854: if (MDOC_BODY == node->next->type)
855: p->flags &= ~TERMP_NOBREAK;
856: else
857: p->flags |= TERMP_NOBREAK;
858: if (node->prev)
859: p->flags |= TERMP_NOLPAD;
860: }
861: break;
862: case (MDOC_Diag):
863: if (MDOC_HEAD == node->type)
864: p->flags |= TERMP_NOBREAK;
865: break;
866: default:
867: break;
868: }
869:
870: /*
871: * Margin control. Set-head-width lists have their right
872: * margins shortened. The body for these lists has the offset
873: * necessarily lengthened. Everybody gets the offset.
874: */
875:
876: p->offset += offset;
877:
878: switch (type) {
879: case (MDOC_Bullet):
880: /* FALLTHROUGH */
881: case (MDOC_Dash):
882: /* FALLTHROUGH */
883: case (MDOC_Enum):
884: /* FALLTHROUGH */
885: case (MDOC_Hyphen):
886: /* FALLTHROUGH */
887: case (MDOC_Tag):
888: if (MDOC_HEAD == node->type)
889: p->rmargin = p->offset + width;
890: else
891: p->offset += width;
892: break;
893: case (MDOC_Column):
894: p->rmargin = p->offset + width;
895: break;
896: default:
897: break;
898: }
899:
900: /*
901: * The dash, hyphen, bullet and enum lists all have a special
1.15 kristaps 902: * HEAD character (temporarily bold, in some cases).
1.1 kristaps 903: */
904:
1.15 kristaps 905: sv = p->flags;
1.1 kristaps 906: if (MDOC_HEAD == node->type)
907: switch (type) {
908: case (MDOC_Bullet):
1.15 kristaps 909: p->flags |= TERMP_BOLD;
1.1 kristaps 910: term_word(p, "\\[bu]");
911: break;
912: case (MDOC_Dash):
913: /* FALLTHROUGH */
914: case (MDOC_Hyphen):
1.15 kristaps 915: p->flags |= TERMP_BOLD;
1.1 kristaps 916: term_word(p, "\\-");
917: break;
918: case (MDOC_Enum):
919: (pair->ppair->ppair->count)++;
920: (void)snprintf(buf, sizeof(buf), "%d.",
921: pair->ppair->ppair->count);
922: term_word(p, buf);
923: break;
924: default:
925: break;
926: }
927:
1.15 kristaps 928: p->flags = sv; /* Restore saved flags. */
929:
1.1 kristaps 930: /*
931: * If we're not going to process our children, indicate so here.
932: */
933:
934: switch (type) {
935: case (MDOC_Bullet):
936: /* FALLTHROUGH */
937: case (MDOC_Item):
938: /* FALLTHROUGH */
939: case (MDOC_Dash):
940: /* FALLTHROUGH */
941: case (MDOC_Hyphen):
942: /* FALLTHROUGH */
943: case (MDOC_Enum):
944: if (MDOC_HEAD == node->type)
945: return(0);
946: break;
947: case (MDOC_Column):
948: if (MDOC_BODY == node->type)
949: return(0);
950: break;
951: default:
952: break;
953: }
954:
955: return(1);
956: }
957:
958:
959: /* ARGSUSED */
960: static void
961: termp_it_post(DECL_ARGS)
962: {
963: int type;
964:
965: if (MDOC_BODY != node->type && MDOC_HEAD != node->type)
966: return;
967:
968: type = arg_listtype(node->parent->parent->parent);
969:
970: switch (type) {
971: case (MDOC_Diag):
972: /* FALLTHROUGH */
973: case (MDOC_Item):
974: /* FALLTHROUGH */
975: case (MDOC_Inset):
976: if (MDOC_BODY == node->type)
977: term_flushln(p);
978: break;
979: case (MDOC_Column):
980: if (MDOC_HEAD == node->type)
981: term_flushln(p);
982: break;
983: default:
984: term_flushln(p);
985: break;
986: }
987:
988: p->offset = pair->offset;
989: p->rmargin = pair->rmargin;
990: p->flags = pair->flag;
991: }
992:
993:
994: /* ARGSUSED */
995: static int
996: termp_nm_pre(DECL_ARGS)
997: {
998:
999: if (SEC_SYNOPSIS == node->sec)
1000: term_newln(p);
1001:
1002: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_PROG]);
1003: if (NULL == node->child)
1004: term_word(p, meta->name);
1005:
1006: return(1);
1007: }
1008:
1009:
1010: /* ARGSUSED */
1011: static int
1012: termp_fl_pre(DECL_ARGS)
1013: {
1014:
1015: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);
1016: term_word(p, "\\-");
1017: p->flags |= TERMP_NOSPACE;
1018: return(1);
1019: }
1020:
1021:
1022: /* ARGSUSED */
1023: static int
1024: termp_ar_pre(DECL_ARGS)
1025: {
1026:
1027: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_ARG]);
1028: return(1);
1029: }
1030:
1031:
1032: /* ARGSUSED */
1033: static int
1034: termp_ns_pre(DECL_ARGS)
1035: {
1036:
1037: p->flags |= TERMP_NOSPACE;
1038: return(1);
1039: }
1040:
1041:
1042: /* ARGSUSED */
1043: static int
1044: termp_pp_pre(DECL_ARGS)
1045: {
1046:
1047: term_vspace(p);
1048: return(1);
1049: }
1050:
1051:
1052: /* ARGSUSED */
1053: static int
1054: termp_st_pre(DECL_ARGS)
1055: {
1056: const char *cp;
1057:
1058: if (node->child && (cp = mdoc_a2st(node->child->string)))
1059: term_word(p, cp);
1060: return(0);
1061: }
1062:
1063:
1064: /* ARGSUSED */
1065: static int
1066: termp_rs_pre(DECL_ARGS)
1067: {
1068:
1069: if (MDOC_BLOCK == node->type && node->prev)
1070: term_vspace(p);
1071: return(1);
1072: }
1073:
1074:
1075: /* ARGSUSED */
1076: static int
1077: termp_rv_pre(DECL_ARGS)
1078: {
1079: int i;
1080:
1.11 kristaps 1081: /* FIXME: mandated by parser. */
1082:
1.1 kristaps 1083: if (-1 == (i = arg_getattr(MDOC_Std, node)))
1084: errx(1, "expected -std argument");
1085: if (1 != node->args->argv[i].sz)
1086: errx(1, "expected -std argument");
1087:
1088: term_newln(p);
1089: term_word(p, "The");
1090:
1091: p->flags |= ttypes[TTYPE_FUNC_NAME];
1092: term_word(p, *node->args->argv[i].value);
1093: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
1094: p->flags |= TERMP_NOSPACE;
1095:
1096: term_word(p, "() function returns the value 0 if successful;");
1097: term_word(p, "otherwise the value -1 is returned and the");
1098: term_word(p, "global variable");
1099:
1100: p->flags |= ttypes[TTYPE_VAR_DECL];
1101: term_word(p, "errno");
1102: p->flags &= ~ttypes[TTYPE_VAR_DECL];
1103:
1104: term_word(p, "is set to indicate the error.");
1105:
1106: return(1);
1107: }
1108:
1109:
1110: /* ARGSUSED */
1111: static int
1112: termp_ex_pre(DECL_ARGS)
1113: {
1114: int i;
1115:
1.11 kristaps 1116: /* FIXME: mandated by parser? */
1117:
1.1 kristaps 1118: if (-1 == (i = arg_getattr(MDOC_Std, node)))
1119: errx(1, "expected -std argument");
1120: if (1 != node->args->argv[i].sz)
1121: errx(1, "expected -std argument");
1122:
1123: term_word(p, "The");
1124: p->flags |= ttypes[TTYPE_PROG];
1125: term_word(p, *node->args->argv[i].value);
1126: p->flags &= ~ttypes[TTYPE_PROG];
1127: term_word(p, "utility exits 0 on success, and >0 if an error occurs.");
1128:
1129: return(1);
1130: }
1131:
1132:
1133: /* ARGSUSED */
1134: static int
1135: termp_nd_pre(DECL_ARGS)
1136: {
1137:
1138: term_word(p, "\\-");
1139: return(1);
1140: }
1141:
1142:
1143: /* ARGSUSED */
1144: static void
1145: termp_bl_post(DECL_ARGS)
1146: {
1147:
1148: if (MDOC_BLOCK == node->type)
1149: term_newln(p);
1150: }
1151:
1152:
1153: /* ARGSUSED */
1154: static void
1155: termp_op_post(DECL_ARGS)
1156: {
1157:
1158: if (MDOC_BODY != node->type)
1159: return;
1160: p->flags |= TERMP_NOSPACE;
1161: term_word(p, "\\(rB");
1162: }
1163:
1164:
1165: /* ARGSUSED */
1166: static int
1167: termp_xr_pre(DECL_ARGS)
1168: {
1169: const struct mdoc_node *n;
1170:
1.11 kristaps 1171: assert(node->child && MDOC_TEXT == node->child->type);
1172: n = node->child;
1173:
1.1 kristaps 1174: term_word(p, n->string);
1175: if (NULL == (n = n->next))
1176: return(0);
1177: p->flags |= TERMP_NOSPACE;
1178: term_word(p, "(");
1179: p->flags |= TERMP_NOSPACE;
1180: term_word(p, n->string);
1181: p->flags |= TERMP_NOSPACE;
1182: term_word(p, ")");
1183: return(0);
1184: }
1185:
1186:
1187: /* ARGSUSED */
1188: static int
1189: termp_vt_pre(DECL_ARGS)
1190: {
1191:
1192: /* FIXME: this can be "type name". */
1193: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);
1194: return(1);
1195: }
1196:
1197:
1198: /* ARGSUSED */
1199: static void
1200: termp_vt_post(DECL_ARGS)
1201: {
1202:
1203: if (node->sec == SEC_SYNOPSIS)
1204: term_vspace(p);
1205: }
1206:
1207:
1208: /* ARGSUSED */
1209: static int
1210: termp_fd_pre(DECL_ARGS)
1211: {
1212:
1213: /*
1214: * FIXME: this naming is bad. This value is used, in general,
1215: * for the #include header or other preprocessor statement.
1216: */
1217: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_DECL]);
1218: return(1);
1219: }
1220:
1221:
1222: /* ARGSUSED */
1223: static void
1224: termp_fd_post(DECL_ARGS)
1225: {
1226:
1227: if (node->sec != SEC_SYNOPSIS)
1228: return;
1229: term_newln(p);
1230: if (node->next && MDOC_Fd != node->next->tok)
1231: term_vspace(p);
1232: }
1233:
1234:
1235: /* ARGSUSED */
1236: static int
1237: termp_sh_pre(DECL_ARGS)
1238: {
1239:
1240: switch (node->type) {
1241: case (MDOC_HEAD):
1242: term_vspace(p);
1243: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SECTION]);
1244: break;
1245: case (MDOC_BODY):
1246: p->offset = INDENT;
1247: break;
1248: default:
1249: break;
1250: }
1251: return(1);
1252: }
1253:
1254:
1255: /* ARGSUSED */
1256: static void
1257: termp_sh_post(DECL_ARGS)
1258: {
1259:
1260: switch (node->type) {
1261: case (MDOC_HEAD):
1262: term_newln(p);
1263: break;
1264: case (MDOC_BODY):
1265: term_newln(p);
1266: p->offset = 0;
1267: break;
1268: default:
1269: break;
1270: }
1271: }
1272:
1273:
1274: /* ARGSUSED */
1275: static int
1276: termp_op_pre(DECL_ARGS)
1277: {
1278:
1279: switch (node->type) {
1280: case (MDOC_BODY):
1281: term_word(p, "\\(lB");
1282: p->flags |= TERMP_NOSPACE;
1283: break;
1284: default:
1285: break;
1286: }
1287: return(1);
1288: }
1289:
1290:
1291: /* ARGSUSED */
1292: static int
1293: termp_bt_pre(DECL_ARGS)
1294: {
1295:
1296: term_word(p, "is currently in beta test.");
1297: return(1);
1298: }
1299:
1300:
1301: /* ARGSUSED */
1302: static int
1303: termp_lb_pre(DECL_ARGS)
1304: {
1305: const char *lb;
1306:
1.11 kristaps 1307: assert(node->child && MDOC_TEXT == node->child->type);
1.1 kristaps 1308: if ((lb = mdoc_a2lib(node->child->string))) {
1309: term_word(p, lb);
1310: return(0);
1311: }
1312: term_word(p, "library");
1313: return(1);
1314: }
1315:
1316:
1317: /* ARGSUSED */
1318: static void
1319: termp_lb_post(DECL_ARGS)
1320: {
1321:
1322: term_newln(p);
1323: }
1324:
1325:
1326: /* ARGSUSED */
1327: static int
1328: termp_ud_pre(DECL_ARGS)
1329: {
1330:
1331: term_word(p, "currently under development.");
1332: return(1);
1333: }
1334:
1335:
1336: /* ARGSUSED */
1337: static int
1338: termp_d1_pre(DECL_ARGS)
1339: {
1340:
1.4 kristaps 1341: if (MDOC_BLOCK != node->type)
1.1 kristaps 1342: return(1);
1343: term_newln(p);
1.16 ! kristaps 1344: pair->offset = INDENT + 1;
! 1345: p->offset += pair->offset;
1.1 kristaps 1346: return(1);
1347: }
1348:
1349:
1350: /* ARGSUSED */
1351: static void
1352: termp_d1_post(DECL_ARGS)
1353: {
1354:
1.4 kristaps 1355: if (MDOC_BLOCK != node->type)
1.1 kristaps 1356: return;
1357: term_newln(p);
1358: p->offset -= pair->offset;
1359: }
1360:
1361:
1362: /* ARGSUSED */
1363: static int
1364: termp_aq_pre(DECL_ARGS)
1365: {
1366:
1367: if (MDOC_BODY != node->type)
1368: return(1);
1369: term_word(p, "\\(la");
1370: p->flags |= TERMP_NOSPACE;
1371: return(1);
1372: }
1373:
1374:
1375: /* ARGSUSED */
1376: static void
1377: termp_aq_post(DECL_ARGS)
1378: {
1379:
1380: if (MDOC_BODY != node->type)
1381: return;
1382: p->flags |= TERMP_NOSPACE;
1383: term_word(p, "\\(ra");
1384: }
1385:
1386:
1387: /* ARGSUSED */
1388: static int
1389: termp_ft_pre(DECL_ARGS)
1390: {
1391:
1392: if (SEC_SYNOPSIS == node->sec)
1393: if (node->prev && MDOC_Fo == node->prev->tok)
1394: term_vspace(p);
1395: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_TYPE]);
1396: return(1);
1397: }
1398:
1399:
1400: /* ARGSUSED */
1401: static void
1402: termp_ft_post(DECL_ARGS)
1403: {
1404:
1405: if (SEC_SYNOPSIS == node->sec)
1406: term_newln(p);
1407: }
1408:
1409:
1410: /* ARGSUSED */
1411: static int
1412: termp_fn_pre(DECL_ARGS)
1413: {
1414: const struct mdoc_node *n;
1415:
1.11 kristaps 1416: assert(node->child && MDOC_TEXT == node->child->type);
1.1 kristaps 1417:
1418: /* FIXME: can be "type funcname" "type varname"... */
1419:
1420: p->flags |= ttypes[TTYPE_FUNC_NAME];
1421: term_word(p, node->child->string);
1422: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
1423:
1424: p->flags |= TERMP_NOSPACE;
1425: term_word(p, "(");
1426:
1427: for (n = node->child->next; n; n = n->next) {
1428: p->flags |= ttypes[TTYPE_FUNC_ARG];
1429: term_word(p, n->string);
1430: p->flags &= ~ttypes[TTYPE_FUNC_ARG];
1431: if (n->next)
1432: term_word(p, ",");
1433: }
1434:
1435: term_word(p, ")");
1436:
1437: if (SEC_SYNOPSIS == node->sec)
1438: term_word(p, ";");
1439:
1440: return(0);
1441: }
1442:
1443:
1444: /* ARGSUSED */
1445: static void
1446: termp_fn_post(DECL_ARGS)
1447: {
1448:
1449: if (node->sec == SEC_SYNOPSIS && node->next)
1450: term_vspace(p);
1451:
1452: }
1453:
1454:
1455: /* ARGSUSED */
1456: static int
1457: termp_sx_pre(DECL_ARGS)
1458: {
1459:
1460: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK]);
1461: return(1);
1462: }
1463:
1464:
1465: /* ARGSUSED */
1466: static int
1467: termp_fa_pre(DECL_ARGS)
1468: {
1469: struct mdoc_node *n;
1470:
1471: if (node->parent->tok != MDOC_Fo) {
1472: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_ARG]);
1473: return(1);
1474: }
1475:
1476: for (n = node->child; n; n = n->next) {
1477: p->flags |= ttypes[TTYPE_FUNC_ARG];
1478: term_word(p, n->string);
1479: p->flags &= ~ttypes[TTYPE_FUNC_ARG];
1480: if (n->next)
1481: term_word(p, ",");
1482: }
1483:
1484: if (node->child && node->next && node->next->tok == MDOC_Fa)
1485: term_word(p, ",");
1486:
1487: return(0);
1488: }
1489:
1490:
1491: /* ARGSUSED */
1492: static int
1493: termp_va_pre(DECL_ARGS)
1494: {
1495:
1496: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);
1497: return(1);
1498: }
1499:
1500:
1501: /* ARGSUSED */
1502: static int
1503: termp_bd_pre(DECL_ARGS)
1504: {
1505: int i, type, ln;
1506:
1507: /*
1508: * This is fairly tricky due primarily to crappy documentation.
1509: * If -ragged or -filled are specified, the block does nothing
1510: * but change the indentation.
1511: *
1512: * If, on the other hand, -unfilled or -literal are specified,
1513: * then the game changes. Text is printed exactly as entered in
1514: * the display: if a macro line, a newline is appended to the
1515: * line. Blank lines are allowed.
1516: */
1517:
1518: if (MDOC_BLOCK == node->type)
1519: return(fmt_block_vspace(p, node, node));
1520: else if (MDOC_BODY != node->type)
1521: return(1);
1522:
1.11 kristaps 1523: /* FIXME: display type should be mandated by parser. */
1524:
1.1 kristaps 1525: if (NULL == node->parent->args)
1526: errx(1, "missing display type");
1527:
1528: pair->offset = p->offset;
1529:
1530: for (type = -1, i = 0;
1531: i < (int)node->parent->args->argc; i++) {
1532: switch (node->parent->args->argv[i].arg) {
1533: case (MDOC_Ragged):
1534: /* FALLTHROUGH */
1535: case (MDOC_Filled):
1536: /* FALLTHROUGH */
1537: case (MDOC_Unfilled):
1538: /* FALLTHROUGH */
1539: case (MDOC_Literal):
1540: type = node->parent->args->argv[i].arg;
1541: i = (int)node->parent->args->argc;
1542: break;
1543: default:
1544: break;
1545: }
1546: }
1547:
1548: if (NULL == node->parent->args)
1549: errx(1, "missing display type");
1550:
1551: i = arg_getattr(MDOC_Offset, node->parent);
1552: if (-1 != i) {
1553: if (1 != node->parent->args->argv[i].sz)
1554: errx(1, "expected single value");
1555: p->offset += arg_offset(&node->parent->args->argv[i]);
1556: }
1557:
1558: switch (type) {
1559: case (MDOC_Literal):
1560: /* FALLTHROUGH */
1561: case (MDOC_Unfilled):
1562: break;
1563: default:
1564: return(1);
1565: }
1566:
1567: /*
1568: * Tricky. Iterate through all children. If we're on a
1569: * different parse line, append a newline and then the contents.
1570: * Ew.
1571: */
1572:
1573: p->flags |= TERMP_LITERAL;
1574: ln = node->child ? node->child->line : 0;
1575:
1576: for (node = node->child; node; node = node->next) {
1577: if (ln < node->line) {
1578: term_flushln(p);
1579: p->flags |= TERMP_NOSPACE;
1580: }
1581: ln = node->line;
1582: print_node(p, pair, meta, node);
1583: }
1584:
1585: return(0);
1586: }
1587:
1588:
1589: /* ARGSUSED */
1590: static void
1591: termp_bd_post(DECL_ARGS)
1592: {
1593:
1594: if (MDOC_BODY != node->type)
1595: return;
1596:
1597: term_flushln(p);
1598: p->flags &= ~TERMP_LITERAL;
1599: p->offset = pair->offset;
1600: p->flags |= TERMP_NOSPACE;
1601: }
1602:
1603:
1604: /* ARGSUSED */
1605: static int
1606: termp_qq_pre(DECL_ARGS)
1607: {
1608:
1609: if (MDOC_BODY != node->type)
1610: return(1);
1611: term_word(p, "\"");
1612: p->flags |= TERMP_NOSPACE;
1613: return(1);
1614: }
1615:
1616:
1617: /* ARGSUSED */
1618: static void
1619: termp_qq_post(DECL_ARGS)
1620: {
1621:
1622: if (MDOC_BODY != node->type)
1623: return;
1624: p->flags |= TERMP_NOSPACE;
1625: term_word(p, "\"");
1626: }
1627:
1628:
1629: /* ARGSUSED */
1630: static int
1631: termp_bsx_pre(DECL_ARGS)
1632: {
1633:
1634: term_word(p, "BSDI BSD/OS");
1635: return(1);
1636: }
1637:
1638:
1639: /* ARGSUSED */
1640: static void
1641: termp_bx_post(DECL_ARGS)
1642: {
1643:
1644: if (node->child)
1645: p->flags |= TERMP_NOSPACE;
1646: term_word(p, "BSD");
1647: }
1648:
1649:
1650: /* ARGSUSED */
1651: static int
1652: termp_ox_pre(DECL_ARGS)
1653: {
1654:
1655: term_word(p, "OpenBSD");
1656: return(1);
1657: }
1658:
1659:
1660: /* ARGSUSED */
1661: static int
1662: termp_dx_pre(DECL_ARGS)
1663: {
1664:
1665: term_word(p, "DragonFly");
1666: return(1);
1667: }
1668:
1669:
1670: /* ARGSUSED */
1671: static int
1672: termp_ux_pre(DECL_ARGS)
1673: {
1674:
1675: term_word(p, "UNIX");
1676: return(1);
1677: }
1678:
1679:
1680: /* ARGSUSED */
1681: static int
1682: termp_fx_pre(DECL_ARGS)
1683: {
1684:
1685: term_word(p, "FreeBSD");
1686: return(1);
1687: }
1688:
1689:
1690: /* ARGSUSED */
1691: static int
1692: termp_nx_pre(DECL_ARGS)
1693: {
1694:
1695: term_word(p, "NetBSD");
1696: return(1);
1697: }
1698:
1699:
1700: /* ARGSUSED */
1701: static int
1702: termp_sq_pre(DECL_ARGS)
1703: {
1704:
1705: if (MDOC_BODY != node->type)
1706: return(1);
1707: term_word(p, "\\(oq");
1708: p->flags |= TERMP_NOSPACE;
1709: return(1);
1710: }
1711:
1712:
1713: /* ARGSUSED */
1714: static void
1715: termp_sq_post(DECL_ARGS)
1716: {
1717:
1718: if (MDOC_BODY != node->type)
1719: return;
1720: p->flags |= TERMP_NOSPACE;
1721: term_word(p, "\\(aq");
1722: }
1723:
1724:
1725: /* ARGSUSED */
1726: static int
1727: termp_pf_pre(DECL_ARGS)
1728: {
1729:
1730: p->flags |= TERMP_IGNDELIM;
1731: return(1);
1732: }
1733:
1734:
1735: /* ARGSUSED */
1736: static void
1737: termp_pf_post(DECL_ARGS)
1738: {
1739:
1740: p->flags &= ~TERMP_IGNDELIM;
1741: p->flags |= TERMP_NOSPACE;
1742: }
1743:
1744:
1745: /* ARGSUSED */
1746: static int
1747: termp_ss_pre(DECL_ARGS)
1748: {
1749:
1750: switch (node->type) {
1751: case (MDOC_BLOCK):
1752: term_newln(p);
1753: if (node->prev)
1754: term_vspace(p);
1755: break;
1756: case (MDOC_HEAD):
1757: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SSECTION]);
1.5 kristaps 1758: p->offset = HALFINDENT;
1.1 kristaps 1759: break;
1760: default:
1761: break;
1762: }
1763:
1764: return(1);
1765: }
1766:
1767:
1768: /* ARGSUSED */
1769: static void
1770: termp_ss_post(DECL_ARGS)
1771: {
1772:
1773: switch (node->type) {
1774: case (MDOC_HEAD):
1775: term_newln(p);
1776: p->offset = INDENT;
1777: break;
1778: default:
1779: break;
1780: }
1781: }
1782:
1783:
1784: /* ARGSUSED */
1785: static int
1786: termp_pa_pre(DECL_ARGS)
1787: {
1788:
1789: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FILE]);
1790: return(1);
1791: }
1792:
1793:
1794: /* ARGSUSED */
1795: static int
1796: termp_em_pre(DECL_ARGS)
1797: {
1798:
1799: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
1800: return(1);
1801: }
1802:
1803:
1804: /* ARGSUSED */
1805: static int
1806: termp_cd_pre(DECL_ARGS)
1807: {
1808:
1809: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CONFIG]);
1810: term_newln(p);
1811: return(1);
1812: }
1813:
1814:
1815: /* ARGSUSED */
1816: static int
1817: termp_cm_pre(DECL_ARGS)
1818: {
1819:
1820: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);
1821: return(1);
1822: }
1823:
1824:
1825: /* ARGSUSED */
1826: static int
1827: termp_ic_pre(DECL_ARGS)
1828: {
1829:
1830: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD]);
1831: return(1);
1832: }
1833:
1834:
1835: /* ARGSUSED */
1836: static int
1837: termp_in_pre(DECL_ARGS)
1838: {
1839:
1840: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_INCLUDE]);
1841: term_word(p, "#include");
1842: term_word(p, "<");
1843: p->flags |= TERMP_NOSPACE;
1844: return(1);
1845: }
1846:
1847:
1848: /* ARGSUSED */
1849: static void
1850: termp_in_post(DECL_ARGS)
1851: {
1852:
1853: p->flags |= TERMP_NOSPACE;
1854: term_word(p, ">");
1855:
1856: term_newln(p);
1857: if (SEC_SYNOPSIS != node->sec)
1858: return;
1859: if (node->next && MDOC_In != node->next->tok)
1860: term_vspace(p);
1861: }
1862:
1863:
1864: /* ARGSUSED */
1865: static int
1866: termp_at_pre(DECL_ARGS)
1867: {
1868: const char *att;
1869:
1870: att = NULL;
1871:
1872: if (node->child)
1873: att = mdoc_a2att(node->child->string);
1874: if (NULL == att)
1875: att = "AT&T UNIX";
1876:
1877: term_word(p, att);
1878: return(0);
1879: }
1880:
1881:
1882: /* ARGSUSED */
1883: static int
1884: termp_brq_pre(DECL_ARGS)
1885: {
1886:
1887: if (MDOC_BODY != node->type)
1888: return(1);
1889: term_word(p, "\\(lC");
1890: p->flags |= TERMP_NOSPACE;
1891: return(1);
1892: }
1893:
1894:
1895: /* ARGSUSED */
1896: static void
1897: termp_brq_post(DECL_ARGS)
1898: {
1899:
1900: if (MDOC_BODY != node->type)
1901: return;
1902: p->flags |= TERMP_NOSPACE;
1903: term_word(p, "\\(rC");
1904: }
1905:
1906:
1907: /* ARGSUSED */
1908: static int
1909: termp_bq_pre(DECL_ARGS)
1910: {
1911:
1912: if (MDOC_BODY != node->type)
1913: return(1);
1914: term_word(p, "\\(lB");
1915: p->flags |= TERMP_NOSPACE;
1916: return(1);
1917: }
1918:
1919:
1920: /* ARGSUSED */
1921: static void
1922: termp_bq_post(DECL_ARGS)
1923: {
1924:
1925: if (MDOC_BODY != node->type)
1926: return;
1927: p->flags |= TERMP_NOSPACE;
1928: term_word(p, "\\(rB");
1929: }
1930:
1931:
1932: /* ARGSUSED */
1933: static int
1934: termp_pq_pre(DECL_ARGS)
1935: {
1936:
1937: if (MDOC_BODY != node->type)
1938: return(1);
1939: term_word(p, "\\&(");
1940: p->flags |= TERMP_NOSPACE;
1941: return(1);
1942: }
1943:
1944:
1945: /* ARGSUSED */
1946: static void
1947: termp_pq_post(DECL_ARGS)
1948: {
1949:
1950: if (MDOC_BODY != node->type)
1951: return;
1952: term_word(p, ")");
1953: }
1954:
1955:
1956: /* ARGSUSED */
1957: static int
1958: termp_fo_pre(DECL_ARGS)
1959: {
1960: const struct mdoc_node *n;
1961:
1962: if (MDOC_BODY == node->type) {
1963: term_word(p, "(");
1964: p->flags |= TERMP_NOSPACE;
1965: return(1);
1966: } else if (MDOC_HEAD != node->type)
1967: return(1);
1968:
1969: /* XXX - groff shows only first parameter */
1970:
1971: p->flags |= ttypes[TTYPE_FUNC_NAME];
1972: for (n = node->child; n; n = n->next) {
1.11 kristaps 1973: assert(MDOC_TEXT == n->type);
1.1 kristaps 1974: term_word(p, n->string);
1975: }
1976: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
1977:
1978: return(0);
1979: }
1980:
1981:
1982: /* ARGSUSED */
1983: static void
1984: termp_fo_post(DECL_ARGS)
1985: {
1986:
1987: if (MDOC_BODY != node->type)
1988: return;
1989: p->flags |= TERMP_NOSPACE;
1990: term_word(p, ")");
1991: p->flags |= TERMP_NOSPACE;
1992: term_word(p, ";");
1993: term_newln(p);
1994: }
1995:
1996:
1997: /* ARGSUSED */
1998: static int
1999: termp_bf_pre(DECL_ARGS)
2000: {
2001: const struct mdoc_node *n;
2002:
2003: if (MDOC_HEAD == node->type) {
2004: return(0);
2005: } else if (MDOC_BLOCK != node->type)
2006: return(1);
2007:
2008: if (NULL == (n = node->head->child)) {
2009: if (arg_hasattr(MDOC_Emphasis, node))
2010: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
2011: else if (arg_hasattr(MDOC_Symbolic, node))
2012: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]);
2013:
2014: return(1);
2015: }
2016:
1.11 kristaps 2017: assert(MDOC_TEXT == n->type);
1.1 kristaps 2018: if (0 == strcmp("Em", n->string))
2019: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
2020: else if (0 == strcmp("Sy", n->string))
2021: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_EMPH]);
2022:
2023: return(1);
2024: }
2025:
2026:
2027: /* ARGSUSED */
2028: static int
2029: termp_sy_pre(DECL_ARGS)
2030: {
2031:
2032: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMB]);
2033: return(1);
2034: }
2035:
2036:
2037: /* ARGSUSED */
2038: static int
2039: termp_ms_pre(DECL_ARGS)
2040: {
2041:
2042: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SYMBOL]);
2043: return(1);
2044: }
2045:
2046:
2047:
2048: /* ARGSUSED */
2049: static int
2050: termp_sm_pre(DECL_ARGS)
2051: {
2052:
1.11 kristaps 2053: assert(node->child && MDOC_TEXT == node->child->type);
1.1 kristaps 2054: if (0 == strcmp("on", node->child->string)) {
2055: p->flags &= ~TERMP_NONOSPACE;
2056: p->flags &= ~TERMP_NOSPACE;
2057: } else
2058: p->flags |= TERMP_NONOSPACE;
2059:
2060: return(0);
2061: }
2062:
2063:
2064: /* ARGSUSED */
2065: static int
2066: termp_ap_pre(DECL_ARGS)
2067: {
2068:
2069: p->flags |= TERMP_NOSPACE;
2070: term_word(p, "\\(aq");
2071: p->flags |= TERMP_NOSPACE;
2072: return(1);
2073: }
2074:
2075:
2076: /* ARGSUSED */
2077: static int
2078: termp__j_pre(DECL_ARGS)
2079: {
2080:
2081: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_REF_JOURNAL]);
2082: return(1);
2083: }
2084:
2085:
2086: /* ARGSUSED */
2087: static int
2088: termp__t_pre(DECL_ARGS)
2089: {
2090:
2091: term_word(p, "\"");
2092: p->flags |= TERMP_NOSPACE;
2093: return(1);
2094: }
2095:
2096:
2097: /* ARGSUSED */
2098: static void
2099: termp__t_post(DECL_ARGS)
2100: {
2101:
2102: p->flags |= TERMP_NOSPACE;
2103: term_word(p, "\"");
2104: termp____post(p, pair, meta, node);
2105: }
2106:
2107:
2108: /* ARGSUSED */
2109: static void
2110: termp____post(DECL_ARGS)
2111: {
2112:
2113: p->flags |= TERMP_NOSPACE;
2114: term_word(p, node->next ? "," : ".");
2115: }
2116:
2117:
2118: /* ARGSUSED */
2119: static int
2120: termp_lk_pre(DECL_ARGS)
2121: {
2122: const struct mdoc_node *n;
2123:
1.11 kristaps 2124: assert(node->child);
2125: n = node->child;
1.1 kristaps 2126:
1.12 kristaps 2127: if (NULL == n->next) {
2128: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK_ANCHOR]);
2129: return(1);
2130: }
2131:
1.1 kristaps 2132: p->flags |= ttypes[TTYPE_LINK_ANCHOR];
2133: term_word(p, n->string);
2134: p->flags |= TERMP_NOSPACE;
2135: term_word(p, ":");
1.12 kristaps 2136: p->flags &= ~ttypes[TTYPE_LINK_ANCHOR];
1.1 kristaps 2137:
2138: p->flags |= ttypes[TTYPE_LINK_TEXT];
1.12 kristaps 2139: for (n = n->next; n; n = n->next)
1.1 kristaps 2140: term_word(p, n->string);
1.12 kristaps 2141:
1.1 kristaps 2142: p->flags &= ~ttypes[TTYPE_LINK_TEXT];
2143: return(0);
2144: }
2145:
2146:
2147: /* ARGSUSED */
2148: static int
2149: termp_mt_pre(DECL_ARGS)
2150: {
2151:
2152: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK_ANCHOR]);
2153: return(1);
2154: }
2155:
2156:
CVSweb