![[BACK]](/icons/back.gif){kind=icon}
Return to mdoc_term.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mandoc|
Return to mdoc_term.c CVS log | Up to [local] / src / usr.bin / mandoc |
1.20 ! schwarze 1: /* $Id: mdoc_term.c,v 1.19 2009/06/27 13:03:51 schwarze Exp $ */
1.1 kristaps 2: /*
1.2 schwarze 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.2 schwarze 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.2 schwarze 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.2 schwarze 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.11 schwarze 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.13 schwarze 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:
306: static int arg_hasattr(int, const struct mdoc_node *);
307: static int arg_getattrs(const int *, int *, size_t,
308: const struct mdoc_node *);
309: static int arg_getattr(int, const struct mdoc_node *);
310: static size_t arg_offset(const struct mdoc_argv *);
311: static size_t arg_width(const struct mdoc_argv *, int);
312: static int arg_listtype(const struct mdoc_node *);
313: static int fmt_block_vspace(struct termp *,
314: const struct mdoc_node *,
315: const struct mdoc_node *);
316: static void print_node(DECL_ARGS);
317: static void print_head(struct termp *,
318: const struct mdoc_meta *);
319: static void print_body(DECL_ARGS);
320: static void print_foot(struct termp *,
321: const struct mdoc_meta *);
322:
323:
324: int
325: mdoc_run(struct termp *p, const struct mdoc *m)
326: {
1.4 schwarze 327: /*
328: * Main output function. When this is called, assume that the
329: * tree is properly formed.
330: */
1.1 kristaps 331:
332: print_head(p, mdoc_meta(m));
1.13 schwarze 333: assert(mdoc_node(m));
334: assert(MDOC_ROOT == mdoc_node(m)->type);
335: if (mdoc_node(m)->child)
336: print_body(p, NULL, mdoc_meta(m), mdoc_node(m)->child);
1.1 kristaps 337: print_foot(p, mdoc_meta(m));
338: return(1);
339: }
340:
341:
342: static void
343: print_body(DECL_ARGS)
344: {
345:
346: print_node(p, pair, meta, node);
347: if ( ! node->next)
348: return;
349: print_body(p, pair, meta, node->next);
350: }
351:
352:
353: static void
354: print_node(DECL_ARGS)
355: {
356: int dochild;
357: struct termpair npair;
358:
359: /* Pre-processing. */
360:
361: dochild = 1;
362: npair.ppair = pair;
363: npair.type = 0;
364: npair.offset = npair.rmargin = 0;
365: npair.flag = 0;
366: npair.count = 0;
367:
368: if (MDOC_TEXT != node->type) {
369: if (termacts[node->tok].pre)
370: if ( ! (*termacts[node->tok].pre)(p, &npair, meta, node))
371: dochild = 0;
372: } else /* MDOC_TEXT == node->type */
373: term_word(p, node->string);
374:
375: /* Children. */
376:
377: if (TERMPAIR_FLAG & npair.type)
378: p->flags |= npair.flag;
379:
380: if (dochild && node->child)
381: print_body(p, &npair, meta, node->child);
382:
383: if (TERMPAIR_FLAG & npair.type)
384: p->flags &= ~npair.flag;
385:
386: /* Post-processing. */
387:
388: if (MDOC_TEXT != node->type)
389: if (termacts[node->tok].post)
390: (*termacts[node->tok].post)(p, &npair, meta, node);
391: }
392:
393:
394: static void
395: print_foot(struct termp *p, const struct mdoc_meta *meta)
396: {
397: struct tm *tm;
398: char *buf, *os;
399:
1.7 schwarze 400: /*
401: * Output the footer in new-groff style, that is, three columns
402: * with the middle being the manual date and flanking columns
403: * being the operating system:
404: *
405: * SYSTEM DATE SYSTEM
406: */
407:
1.1 kristaps 408: if (NULL == (buf = malloc(p->rmargin)))
409: err(1, "malloc");
410: if (NULL == (os = malloc(p->rmargin)))
411: err(1, "malloc");
412:
413: tm = localtime(&meta->date);
414:
1.5 schwarze 415: if (0 == strftime(buf, p->rmargin, "%B %d, %Y", tm))
1.1 kristaps 416: err(1, "strftime");
417:
418: (void)strlcpy(os, meta->os, p->rmargin);
419:
420: term_vspace(p);
421:
1.7 schwarze 422: p->offset = 0;
423: p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
1.1 kristaps 424: p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
425:
426: term_word(p, os);
427: term_flushln(p);
428:
1.7 schwarze 429: p->offset = p->rmargin;
430: p->rmargin = p->maxrmargin - strlen(os);
1.1 kristaps 431: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1.7 schwarze 432:
433: term_word(p, buf);
434: term_flushln(p);
435:
1.1 kristaps 436: p->offset = p->rmargin;
437: p->rmargin = p->maxrmargin;
438: p->flags &= ~TERMP_NOBREAK;
1.7 schwarze 439: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1.1 kristaps 440:
1.7 schwarze 441: term_word(p, os);
1.1 kristaps 442: term_flushln(p);
1.7 schwarze 443:
444: p->offset = 0;
445: p->rmargin = p->maxrmargin;
446: p->flags = 0;
1.1 kristaps 447:
448: free(buf);
449: free(os);
450: }
451:
452:
453: static void
454: print_head(struct termp *p, const struct mdoc_meta *meta)
455: {
456: char *buf, *title;
457:
458: p->rmargin = p->maxrmargin;
459: p->offset = 0;
460:
461: if (NULL == (buf = malloc(p->rmargin)))
462: err(1, "malloc");
463: if (NULL == (title = malloc(p->rmargin)))
464: err(1, "malloc");
465:
466: /*
467: * The header is strange. It has three components, which are
468: * really two with the first duplicated. It goes like this:
469: *
470: * IDENTIFIER TITLE IDENTIFIER
471: *
472: * The IDENTIFIER is NAME(SECTION), which is the command-name
473: * (if given, or "unknown" if not) followed by the manual page
474: * section. These are given in `Dt'. The TITLE is a free-form
475: * string depending on the manual volume. If not specified, it
476: * switches on the manual section.
477: */
478:
479: assert(meta->vol);
480: (void)strlcpy(buf, meta->vol, p->rmargin);
481:
482: if (meta->arch) {
483: (void)strlcat(buf, " (", p->rmargin);
484: (void)strlcat(buf, meta->arch, p->rmargin);
485: (void)strlcat(buf, ")", p->rmargin);
486: }
487:
488: (void)snprintf(title, p->rmargin, "%s(%d)",
489: meta->title, meta->msec);
490:
491: p->offset = 0;
1.8 schwarze 492: p->rmargin = (p->maxrmargin - strlen(buf) + 1) / 2;
1.1 kristaps 493: p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
494:
495: term_word(p, title);
496: term_flushln(p);
497:
498: p->offset = p->rmargin;
499: p->rmargin = p->maxrmargin - strlen(title);
1.8 schwarze 500: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
1.1 kristaps 501:
502: term_word(p, buf);
503: term_flushln(p);
504:
505: p->offset = p->rmargin;
506: p->rmargin = p->maxrmargin;
507: p->flags &= ~TERMP_NOBREAK;
508: p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;
509:
510: term_word(p, title);
511: term_flushln(p);
512:
1.8 schwarze 513: p->offset = 0;
1.1 kristaps 514: p->rmargin = p->maxrmargin;
515: p->flags &= ~TERMP_NOSPACE;
516:
517: free(title);
518: free(buf);
519: }
520:
521:
522: static size_t
523: arg_width(const struct mdoc_argv *arg, int pos)
524: {
525: size_t v;
526: int i, len;
527:
528: assert(pos < (int)arg->sz && pos >= 0);
529: assert(arg->value[pos]);
530: if (0 == strcmp(arg->value[pos], "indent"))
531: return(INDENT);
532: if (0 == strcmp(arg->value[pos], "indent-two"))
533: return(INDENT * 2);
534:
535: if (0 == (len = (int)strlen(arg->value[pos])))
536: return(0);
537:
538: for (i = 0; i < len - 1; i++)
539: if ( ! isdigit((u_char)arg->value[pos][i]))
540: break;
541:
542: if (i == len - 1) {
1.15 schwarze 543: if ('n' == arg->value[pos][len - 1] ||
544: 'm' == arg->value[pos][len - 1]) {
1.1 kristaps 545: v = (size_t)atoi(arg->value[pos]);
1.18 schwarze 546: return(v + 2);
1.1 kristaps 547: }
548:
549: }
1.18 schwarze 550: return(strlen(arg->value[pos]) + 2);
1.1 kristaps 551: }
552:
553:
554: static int
555: arg_listtype(const struct mdoc_node *n)
556: {
557: int i, len;
558:
559: assert(MDOC_BLOCK == n->type);
560:
561: len = (int)(n->args ? n->args->argc : 0);
562:
563: for (i = 0; i < len; i++)
564: switch (n->args->argv[i].arg) {
565: case (MDOC_Bullet):
566: /* FALLTHROUGH */
567: case (MDOC_Dash):
568: /* FALLTHROUGH */
569: case (MDOC_Enum):
570: /* FALLTHROUGH */
571: case (MDOC_Hyphen):
572: /* FALLTHROUGH */
573: case (MDOC_Tag):
574: /* FALLTHROUGH */
575: case (MDOC_Inset):
576: /* FALLTHROUGH */
577: case (MDOC_Diag):
578: /* FALLTHROUGH */
579: case (MDOC_Item):
580: /* FALLTHROUGH */
581: case (MDOC_Column):
582: /* FALLTHROUGH */
583: case (MDOC_Ohang):
584: return(n->args->argv[i].arg);
585: default:
586: break;
587: }
588:
1.10 schwarze 589: /* FIXME: mandated by parser. */
590:
1.1 kristaps 591: errx(1, "list type not supported");
592: /* NOTREACHED */
593: }
594:
595:
596: static size_t
597: arg_offset(const struct mdoc_argv *arg)
598: {
599:
600: assert(*arg->value);
1.9 schwarze 601: if (0 == strcmp(*arg->value, "left"))
602: return(0);
1.1 kristaps 603: if (0 == strcmp(*arg->value, "indent"))
1.17 schwarze 604: return(INDENT + 1);
1.1 kristaps 605: if (0 == strcmp(*arg->value, "indent-two"))
1.20 ! schwarze 606: return((INDENT + 1) * 2);
1.10 schwarze 607:
608: /* FIXME: needs to support field-widths (10n, etc.). */
609:
1.1 kristaps 610: return(strlen(*arg->value));
611: }
612:
613:
614: static int
615: arg_hasattr(int arg, const struct mdoc_node *n)
616: {
617:
618: return(-1 != arg_getattr(arg, n));
619: }
620:
621:
622: static int
623: arg_getattr(int v, const struct mdoc_node *n)
624: {
625: int val;
626:
627: return(arg_getattrs(&v, &val, 1, n) ? val : -1);
628: }
629:
630:
631: static int
632: arg_getattrs(const int *keys, int *vals,
633: size_t sz, const struct mdoc_node *n)
634: {
635: int i, j, k;
636:
637: if (NULL == n->args)
638: return(0);
639:
640: for (k = i = 0; i < (int)n->args->argc; i++)
641: for (j = 0; j < (int)sz; j++)
642: if (n->args->argv[i].arg == keys[j]) {
643: vals[j] = i;
644: k++;
645: }
646: return(k);
647: }
648:
649:
650: /* ARGSUSED */
651: static int
652: fmt_block_vspace(struct termp *p,
653: const struct mdoc_node *bl,
654: const struct mdoc_node *node)
655: {
656: const struct mdoc_node *n;
657:
658: term_newln(p);
659:
660: if (arg_hasattr(MDOC_Compact, bl))
661: return(1);
662:
663: for (n = node; n; n = n->parent) {
664: if (MDOC_BLOCK != n->type)
665: continue;
666: if (MDOC_Ss == n->tok)
667: break;
668: if (MDOC_Sh == n->tok)
669: break;
670: if (NULL == n->prev)
671: continue;
672: term_vspace(p);
673: break;
674: }
675:
676: return(1);
677: }
678:
679:
680: /* ARGSUSED */
681: static int
682: termp_dq_pre(DECL_ARGS)
683: {
684:
685: if (MDOC_BODY != node->type)
686: return(1);
687:
688: term_word(p, "\\(lq");
689: p->flags |= TERMP_NOSPACE;
690: return(1);
691: }
692:
693:
694: /* ARGSUSED */
695: static void
696: termp_dq_post(DECL_ARGS)
697: {
698:
699: if (MDOC_BODY != node->type)
700: return;
701:
702: p->flags |= TERMP_NOSPACE;
703: term_word(p, "\\(rq");
704: }
705:
706:
707: /* ARGSUSED */
708: static int
709: termp_it_pre(DECL_ARGS)
710: {
711: const struct mdoc_node *bl, *n;
712: char buf[7];
1.12 schwarze 713: int i, type, keys[3], vals[3], sv;
1.1 kristaps 714: size_t width, offset;
715:
716: if (MDOC_BLOCK == node->type)
717: return(fmt_block_vspace(p, node->parent->parent, node));
718:
719: bl = node->parent->parent->parent;
720:
721: /* Save parent attributes. */
722:
723: pair->offset = p->offset;
724: pair->rmargin = p->rmargin;
725: pair->flag = p->flags;
726:
727: /* Get list width and offset. */
728:
729: keys[0] = MDOC_Width;
730: keys[1] = MDOC_Offset;
731: keys[2] = MDOC_Column;
732:
733: vals[0] = vals[1] = vals[2] = -1;
734:
735: width = offset = 0;
736:
737: (void)arg_getattrs(keys, vals, 3, bl);
738:
739: type = arg_listtype(bl);
740:
741: /* Calculate real width and offset. */
742:
743: switch (type) {
744: case (MDOC_Column):
745: if (MDOC_BODY == node->type)
746: break;
747: for (i = 0, n = node->prev; n; n = n->prev, i++)
748: offset += arg_width
749: (&bl->args->argv[vals[2]], i);
750: assert(i < (int)bl->args->argv[vals[2]].sz);
751: width = arg_width(&bl->args->argv[vals[2]], i);
752: if (vals[1] >= 0)
753: offset += arg_offset(&bl->args->argv[vals[1]]);
754: break;
755: default:
756: if (vals[0] >= 0)
757: width = arg_width(&bl->args->argv[vals[0]], 0);
758: if (vals[1] >= 0)
759: offset = arg_offset(&bl->args->argv[vals[1]]);
760: break;
761: }
762:
763: /*
764: * List-type can override the width in the case of fixed-head
765: * values (bullet, dash/hyphen, enum). Tags need a non-zero
766: * offset.
767: */
768:
769: switch (type) {
770: case (MDOC_Bullet):
771: /* FALLTHROUGH */
772: case (MDOC_Dash):
773: /* FALLTHROUGH */
774: case (MDOC_Hyphen):
775: if (width < 4)
776: width = 4;
1.19 schwarze 777: break;
778: case (MDOC_Enum):
779: if (width < 5)
780: width = 5;
1.1 kristaps 781: break;
782: case (MDOC_Tag):
783: if (0 == width)
784: width = 10;
785: break;
786: default:
787: break;
788: }
789:
790: /*
1.16 schwarze 791: * Whitespace control. Inset bodies need an initial space,
792: * while diagonal bodies need two.
1.1 kristaps 793: */
794:
795: switch (type) {
796: case (MDOC_Diag):
1.16 schwarze 797: term_word(p, "\\ ");
1.1 kristaps 798: /* FALLTHROUGH */
799: case (MDOC_Inset):
800: if (MDOC_BODY == node->type)
801: p->flags &= ~TERMP_NOSPACE;
802: else
803: p->flags |= TERMP_NOSPACE;
804: break;
805: default:
806: p->flags |= TERMP_NOSPACE;
807: break;
808: }
809:
810: /*
811: * Style flags. Diagnostic heads need TTYPE_DIAG.
812: */
813:
814: switch (type) {
815: case (MDOC_Diag):
816: if (MDOC_HEAD == node->type)
817: p->flags |= ttypes[TTYPE_DIAG];
818: break;
819: default:
820: break;
821: }
822:
823: /*
824: * Pad and break control. This is the tricker part. Lists with
825: * set right-margins for the head get TERMP_NOBREAK because, if
826: * they overrun the margin, they wrap to the new margin.
827: * Correspondingly, the body for these types don't left-pad, as
828: * the head will pad out to to the right.
829: */
830:
831: switch (type) {
832: case (MDOC_Bullet):
833: /* FALLTHROUGH */
834: case (MDOC_Dash):
835: /* FALLTHROUGH */
836: case (MDOC_Enum):
837: /* FALLTHROUGH */
838: case (MDOC_Hyphen):
839: /* FALLTHROUGH */
840: case (MDOC_Tag):
841: if (MDOC_HEAD == node->type)
842: p->flags |= TERMP_NOBREAK;
843: else
844: p->flags |= TERMP_NOLPAD;
845: if (MDOC_HEAD == node->type && MDOC_Tag == type)
846: if (NULL == node->next ||
847: NULL == node->next->child)
848: p->flags |= TERMP_NONOBREAK;
849: break;
850: case (MDOC_Column):
851: if (MDOC_HEAD == node->type) {
852: assert(node->next);
853: if (MDOC_BODY == node->next->type)
854: p->flags &= ~TERMP_NOBREAK;
855: else
856: p->flags |= TERMP_NOBREAK;
857: if (node->prev)
858: p->flags |= TERMP_NOLPAD;
859: }
860: break;
861: case (MDOC_Diag):
862: if (MDOC_HEAD == node->type)
863: p->flags |= TERMP_NOBREAK;
864: break;
865: default:
866: break;
867: }
868:
869: /*
870: * Margin control. Set-head-width lists have their right
871: * margins shortened. The body for these lists has the offset
872: * necessarily lengthened. Everybody gets the offset.
873: */
874:
875: p->offset += offset;
876:
877: switch (type) {
878: case (MDOC_Bullet):
879: /* FALLTHROUGH */
880: case (MDOC_Dash):
881: /* FALLTHROUGH */
882: case (MDOC_Enum):
883: /* FALLTHROUGH */
884: case (MDOC_Hyphen):
885: /* FALLTHROUGH */
886: case (MDOC_Tag):
887: if (MDOC_HEAD == node->type)
888: p->rmargin = p->offset + width;
889: else
890: p->offset += width;
891: break;
892: case (MDOC_Column):
893: p->rmargin = p->offset + width;
894: break;
895: default:
896: break;
897: }
898:
899: /*
900: * The dash, hyphen, bullet and enum lists all have a special
1.12 schwarze 901: * HEAD character (temporarily bold, in some cases).
1.1 kristaps 902: */
903:
1.12 schwarze 904: sv = p->flags;
1.1 kristaps 905: if (MDOC_HEAD == node->type)
906: switch (type) {
907: case (MDOC_Bullet):
1.12 schwarze 908: p->flags |= TERMP_BOLD;
1.1 kristaps 909: term_word(p, "\\[bu]");
910: break;
911: case (MDOC_Dash):
912: /* FALLTHROUGH */
913: case (MDOC_Hyphen):
1.12 schwarze 914: p->flags |= TERMP_BOLD;
1.1 kristaps 915: term_word(p, "\\-");
916: break;
917: case (MDOC_Enum):
918: (pair->ppair->ppair->count)++;
919: (void)snprintf(buf, sizeof(buf), "%d.",
920: pair->ppair->ppair->count);
921: term_word(p, buf);
922: break;
923: default:
924: break;
925: }
1.12 schwarze 926:
927: p->flags = sv; /* Restore saved flags. */
1.1 kristaps 928:
929: /*
930: * If we're not going to process our children, indicate so here.
931: */
932:
933: switch (type) {
934: case (MDOC_Bullet):
935: /* FALLTHROUGH */
936: case (MDOC_Item):
937: /* FALLTHROUGH */
938: case (MDOC_Dash):
939: /* FALLTHROUGH */
940: case (MDOC_Hyphen):
941: /* FALLTHROUGH */
942: case (MDOC_Enum):
943: if (MDOC_HEAD == node->type)
944: return(0);
945: break;
946: case (MDOC_Column):
947: if (MDOC_BODY == node->type)
948: return(0);
949: break;
950: default:
951: break;
952: }
953:
954: return(1);
955: }
956:
957:
958: /* ARGSUSED */
959: static void
960: termp_it_post(DECL_ARGS)
961: {
962: int type;
963:
964: if (MDOC_BODY != node->type && MDOC_HEAD != node->type)
965: return;
966:
967: type = arg_listtype(node->parent->parent->parent);
968:
969: switch (type) {
970: case (MDOC_Diag):
971: /* FALLTHROUGH */
972: case (MDOC_Item):
973: /* FALLTHROUGH */
974: case (MDOC_Inset):
975: if (MDOC_BODY == node->type)
976: term_flushln(p);
977: break;
978: case (MDOC_Column):
979: if (MDOC_HEAD == node->type)
980: term_flushln(p);
981: break;
982: default:
983: term_flushln(p);
984: break;
985: }
986:
987: p->offset = pair->offset;
988: p->rmargin = pair->rmargin;
989: p->flags = pair->flag;
990: }
991:
992:
993: /* ARGSUSED */
994: static int
995: termp_nm_pre(DECL_ARGS)
996: {
997:
998: if (SEC_SYNOPSIS == node->sec)
999: term_newln(p);
1000:
1001: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_PROG]);
1002: if (NULL == node->child)
1003: term_word(p, meta->name);
1004:
1005: return(1);
1006: }
1007:
1008:
1009: /* ARGSUSED */
1010: static int
1011: termp_fl_pre(DECL_ARGS)
1012: {
1013:
1014: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_FLAG]);
1015: term_word(p, "\\-");
1016: p->flags |= TERMP_NOSPACE;
1017: return(1);
1018: }
1019:
1020:
1021: /* ARGSUSED */
1022: static int
1023: termp_ar_pre(DECL_ARGS)
1024: {
1025:
1026: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_CMD_ARG]);
1027: return(1);
1028: }
1029:
1030:
1031: /* ARGSUSED */
1032: static int
1033: termp_ns_pre(DECL_ARGS)
1034: {
1035:
1036: p->flags |= TERMP_NOSPACE;
1037: return(1);
1038: }
1039:
1040:
1041: /* ARGSUSED */
1042: static int
1043: termp_pp_pre(DECL_ARGS)
1044: {
1045:
1046: term_vspace(p);
1047: return(1);
1048: }
1049:
1050:
1051: /* ARGSUSED */
1052: static int
1053: termp_st_pre(DECL_ARGS)
1054: {
1055: const char *cp;
1056:
1057: if (node->child && (cp = mdoc_a2st(node->child->string)))
1058: term_word(p, cp);
1059: return(0);
1060: }
1061:
1062:
1063: /* ARGSUSED */
1064: static int
1065: termp_rs_pre(DECL_ARGS)
1066: {
1067:
1068: if (MDOC_BLOCK == node->type && node->prev)
1069: term_vspace(p);
1070: return(1);
1071: }
1072:
1073:
1074: /* ARGSUSED */
1075: static int
1076: termp_rv_pre(DECL_ARGS)
1077: {
1078: int i;
1079:
1.10 schwarze 1080: /* FIXME: mandated by parser. */
1081:
1.1 kristaps 1082: if (-1 == (i = arg_getattr(MDOC_Std, node)))
1083: errx(1, "expected -std argument");
1084: if (1 != node->args->argv[i].sz)
1085: errx(1, "expected -std argument");
1086:
1087: term_newln(p);
1088: term_word(p, "The");
1089:
1090: p->flags |= ttypes[TTYPE_FUNC_NAME];
1091: term_word(p, *node->args->argv[i].value);
1092: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
1093: p->flags |= TERMP_NOSPACE;
1094:
1095: term_word(p, "() function returns the value 0 if successful;");
1096: term_word(p, "otherwise the value -1 is returned and the");
1097: term_word(p, "global variable");
1098:
1099: p->flags |= ttypes[TTYPE_VAR_DECL];
1100: term_word(p, "errno");
1101: p->flags &= ~ttypes[TTYPE_VAR_DECL];
1102:
1103: term_word(p, "is set to indicate the error.");
1104:
1105: return(1);
1106: }
1107:
1108:
1109: /* ARGSUSED */
1110: static int
1111: termp_ex_pre(DECL_ARGS)
1112: {
1113: int i;
1114:
1.10 schwarze 1115: /* FIXME: mandated by parser? */
1116:
1.1 kristaps 1117: if (-1 == (i = arg_getattr(MDOC_Std, node)))
1118: errx(1, "expected -std argument");
1119: if (1 != node->args->argv[i].sz)
1120: errx(1, "expected -std argument");
1121:
1122: term_word(p, "The");
1123: p->flags |= ttypes[TTYPE_PROG];
1124: term_word(p, *node->args->argv[i].value);
1125: p->flags &= ~ttypes[TTYPE_PROG];
1126: term_word(p, "utility exits 0 on success, and >0 if an error occurs.");
1127:
1128: return(1);
1129: }
1130:
1131:
1132: /* ARGSUSED */
1133: static int
1134: termp_nd_pre(DECL_ARGS)
1135: {
1136:
1137: term_word(p, "\\-");
1138: return(1);
1139: }
1140:
1141:
1142: /* ARGSUSED */
1143: static void
1144: termp_bl_post(DECL_ARGS)
1145: {
1146:
1147: if (MDOC_BLOCK == node->type)
1148: term_newln(p);
1149: }
1150:
1151:
1152: /* ARGSUSED */
1153: static void
1154: termp_op_post(DECL_ARGS)
1155: {
1156:
1157: if (MDOC_BODY != node->type)
1158: return;
1159: p->flags |= TERMP_NOSPACE;
1160: term_word(p, "\\(rB");
1161: }
1162:
1163:
1164: /* ARGSUSED */
1165: static int
1166: termp_xr_pre(DECL_ARGS)
1167: {
1168: const struct mdoc_node *n;
1169:
1.10 schwarze 1170: assert(node->child && MDOC_TEXT == node->child->type);
1171: n = node->child;
1172:
1.1 kristaps 1173: term_word(p, n->string);
1174: if (NULL == (n = n->next))
1175: return(0);
1176: p->flags |= TERMP_NOSPACE;
1177: term_word(p, "(");
1178: p->flags |= TERMP_NOSPACE;
1179: term_word(p, n->string);
1180: p->flags |= TERMP_NOSPACE;
1181: term_word(p, ")");
1182: return(0);
1183: }
1184:
1185:
1186: /* ARGSUSED */
1187: static int
1188: termp_vt_pre(DECL_ARGS)
1189: {
1190:
1191: /* FIXME: this can be "type name". */
1192: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_VAR_DECL]);
1193: return(1);
1194: }
1195:
1196:
1197: /* ARGSUSED */
1198: static void
1199: termp_vt_post(DECL_ARGS)
1200: {
1201:
1202: if (node->sec == SEC_SYNOPSIS)
1203: term_vspace(p);
1204: }
1205:
1206:
1207: /* ARGSUSED */
1208: static int
1209: termp_fd_pre(DECL_ARGS)
1210: {
1211:
1212: /*
1213: * FIXME: this naming is bad. This value is used, in general,
1214: * for the #include header or other preprocessor statement.
1215: */
1216: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_FUNC_DECL]);
1217: return(1);
1218: }
1219:
1220:
1221: /* ARGSUSED */
1222: static void
1223: termp_fd_post(DECL_ARGS)
1224: {
1225:
1226: if (node->sec != SEC_SYNOPSIS)
1227: return;
1228: term_newln(p);
1229: if (node->next && MDOC_Fd != node->next->tok)
1230: term_vspace(p);
1231: }
1232:
1233:
1234: /* ARGSUSED */
1235: static int
1236: termp_sh_pre(DECL_ARGS)
1237: {
1238:
1239: switch (node->type) {
1240: case (MDOC_HEAD):
1241: term_vspace(p);
1242: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_SECTION]);
1243: break;
1244: case (MDOC_BODY):
1245: p->offset = INDENT;
1246: break;
1247: default:
1248: break;
1249: }
1250: return(1);
1251: }
1252:
1253:
1254: /* ARGSUSED */
1255: static void
1256: termp_sh_post(DECL_ARGS)
1257: {
1258:
1259: switch (node->type) {
1260: case (MDOC_HEAD):
1261: term_newln(p);
1262: break;
1263: case (MDOC_BODY):
1264: term_newln(p);
1265: p->offset = 0;
1266: break;
1267: default:
1268: break;
1269: }
1270: }
1271:
1272:
1273: /* ARGSUSED */
1274: static int
1275: termp_op_pre(DECL_ARGS)
1276: {
1277:
1278: switch (node->type) {
1279: case (MDOC_BODY):
1280: term_word(p, "\\(lB");
1281: p->flags |= TERMP_NOSPACE;
1282: break;
1283: default:
1284: break;
1285: }
1286: return(1);
1287: }
1288:
1289:
1290: /* ARGSUSED */
1291: static int
1292: termp_bt_pre(DECL_ARGS)
1293: {
1294:
1295: term_word(p, "is currently in beta test.");
1296: return(1);
1297: }
1298:
1299:
1300: /* ARGSUSED */
1301: static int
1302: termp_lb_pre(DECL_ARGS)
1303: {
1304: const char *lb;
1305:
1.10 schwarze 1306: assert(node->child && MDOC_TEXT == node->child->type);
1.14 schwarze 1307: lb = mdoc_a2lib(node->child->string);
1308: if (lb) {
1.1 kristaps 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:
1341: if (MDOC_BLOCK != node->type)
1342: return(1);
1343: term_newln(p);
1.14 schwarze 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:
1355: if (MDOC_BLOCK != node->type)
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.10 schwarze 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.10 schwarze 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.3 schwarze 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.10 schwarze 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.10 schwarze 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.10 schwarze 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.6 schwarze 2124: assert(node->child);
2125: n = node->child;
2126:
2127: if (NULL == n->next) {
2128: TERMPAIR_SETFLAG(p, pair, ttypes[TTYPE_LINK_ANCHOR]);
2129: return(1);
2130: }
1.1 kristaps 2131:
2132: p->flags |= ttypes[TTYPE_LINK_ANCHOR];
2133: term_word(p, n->string);
2134: p->flags |= TERMP_NOSPACE;
2135: term_word(p, ":");
1.6 schwarze 2136: p->flags &= ~ttypes[TTYPE_LINK_ANCHOR];
1.1 kristaps 2137:
2138: p->flags |= ttypes[TTYPE_LINK_TEXT];
1.6 schwarze 2139: for (n = n->next; n; n = n->next)
1.1 kristaps 2140: term_word(p, n->string);
1.6 schwarze 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: