Annotation of mandoc/term.c, Revision 1.22
1.22 ! kristaps 1: /* $Id: term.c,v 1.21 2009/02/25 15:12:26 kristaps Exp $ */
1.1 kristaps 2: /*
1.10 kristaps 3: * Copyright (c) 2009 Kristaps Dzonsons <kristaps@kth.se>
1.1 kristaps 4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the
7: * above copyright notice and this permission notice appear in all
8: * copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11: * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12: * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13: * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14: * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15: * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16: * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17: * PERFORMANCE OF THIS SOFTWARE.
18: */
19: #include <assert.h>
1.22 ! kristaps 20: #include <stdio.h>
1.1 kristaps 21: #include <stdlib.h>
22: #include <string.h>
23:
1.10 kristaps 24: #include "term.h"
25:
26: #define INDENT 4
27:
28: /*
29: * Performs actions on nodes of the abstract syntax tree. Both pre- and
30: * post-fix operations are defined here.
31: */
32:
33: /* FIXME: indent/tab. */
1.21 kristaps 34: /* FIXME: macro arguments can be escaped. */
1.10 kristaps 35:
36: #define TTYPE_PROG 0
37: #define TTYPE_CMD_FLAG 1
38: #define TTYPE_CMD_ARG 2
39: #define TTYPE_SECTION 3
40: #define TTYPE_FUNC_DECL 4
41: #define TTYPE_VAR_DECL 5
42: #define TTYPE_FUNC_TYPE 6
43: #define TTYPE_FUNC_NAME 7
44: #define TTYPE_FUNC_ARG 8
45: #define TTYPE_LINK 9
46: #define TTYPE_SSECTION 10
47: #define TTYPE_FILE 11
1.11 kristaps 48: #define TTYPE_EMPH 12
1.14 kristaps 49: #define TTYPE_CONFIG 13
50: #define TTYPE_CMD 14
51: #define TTYPE_INCLUDE 15
1.17 kristaps 52: #define TTYPE_SYMB 16
53: #define TTYPE_SYMBOL 17
54: #define TTYPE_NMAX 18
1.10 kristaps 55:
56: /*
57: * These define "styles" for element types, like command arguments or
58: * executable names. This is useful when multiple macros must decorate
59: * the same thing (like .Ex -std cmd and .Nm cmd).
60: */
61:
62: const int ttypes[TTYPE_NMAX] = {
63: TERMP_BOLD, /* TTYPE_PROG */
64: TERMP_BOLD, /* TTYPE_CMD_FLAG */
65: TERMP_UNDERLINE, /* TTYPE_CMD_ARG */
66: TERMP_BOLD, /* TTYPE_SECTION */
67: TERMP_BOLD, /* TTYPE_FUNC_DECL */
68: TERMP_UNDERLINE, /* TTYPE_VAR_DECL */
69: TERMP_UNDERLINE, /* TTYPE_FUNC_TYPE */
70: TERMP_BOLD, /* TTYPE_FUNC_NAME */
71: TERMP_UNDERLINE, /* TTYPE_FUNC_ARG */
72: TERMP_UNDERLINE, /* TTYPE_LINK */
73: TERMP_BOLD, /* TTYPE_SSECTION */
1.11 kristaps 74: TERMP_UNDERLINE, /* TTYPE_FILE */
1.14 kristaps 75: TERMP_UNDERLINE, /* TTYPE_EMPH */
76: TERMP_BOLD, /* TTYPE_CONFIG */
77: TERMP_BOLD, /* TTYPE_CMD */
1.17 kristaps 78: TERMP_BOLD, /* TTYPE_INCLUDE */
79: TERMP_BOLD, /* TTYPE_SYMB */
80: TERMP_BOLD /* TTYPE_SYMBOL */
1.10 kristaps 81: };
1.7 kristaps 82:
1.10 kristaps 83: static int arg_hasattr(int, size_t,
84: const struct mdoc_arg *);
85: static int arg_getattr(int, size_t,
86: const struct mdoc_arg *);
1.12 kristaps 87: static size_t arg_offset(const struct mdoc_arg *);
88: static size_t arg_width(const struct mdoc_arg *);
1.10 kristaps 89:
90: /*
91: * What follows describes prefix and postfix operations for the abstract
92: * syntax tree descent.
93: */
1.1 kristaps 94:
1.10 kristaps 95: #define DECL_ARGS \
96: struct termp *p, \
1.18 kristaps 97: struct termpair *pair, \
1.10 kristaps 98: const struct mdoc_meta *meta, \
99: const struct mdoc_node *node
100:
101: #define DECL_PRE(name) \
102: static int name##_pre(DECL_ARGS)
103: #define DECL_POST(name) \
104: static void name##_post(DECL_ARGS)
105: #define DECL_PREPOST(name) \
106: DECL_PRE(name); \
107: DECL_POST(name);
108:
109: DECL_PREPOST(termp_aq);
1.12 kristaps 110: DECL_PREPOST(termp_bd);
1.15 kristaps 111: DECL_PREPOST(termp_bq);
1.10 kristaps 112: DECL_PREPOST(termp_d1);
113: DECL_PREPOST(termp_dq);
114: DECL_PREPOST(termp_fd);
115: DECL_PREPOST(termp_fn);
1.16 kristaps 116: DECL_PREPOST(termp_fo);
1.10 kristaps 117: DECL_PREPOST(termp_ft);
118: DECL_PREPOST(termp_it);
119: DECL_PREPOST(termp_op);
120: DECL_PREPOST(termp_pf);
1.15 kristaps 121: DECL_PREPOST(termp_pq);
1.10 kristaps 122: DECL_PREPOST(termp_qq);
123: DECL_PREPOST(termp_sh);
124: DECL_PREPOST(termp_ss);
125: DECL_PREPOST(termp_sq);
126: DECL_PREPOST(termp_vt);
127:
1.18 kristaps 128: DECL_PRE(termp_ar);
1.14 kristaps 129: DECL_PRE(termp_at);
1.18 kristaps 130: DECL_PRE(termp_bf);
1.15 kristaps 131: DECL_PRE(termp_bsx);
1.17 kristaps 132: DECL_PRE(termp_bt);
1.10 kristaps 133: DECL_PRE(termp_bx);
1.18 kristaps 134: DECL_PRE(termp_cd);
135: DECL_PRE(termp_cm);
136: DECL_PRE(termp_em);
1.10 kristaps 137: DECL_PRE(termp_ex);
1.18 kristaps 138: DECL_PRE(termp_fa);
139: DECL_PRE(termp_fl);
1.16 kristaps 140: DECL_PRE(termp_fx);
1.18 kristaps 141: DECL_PRE(termp_ic);
142: DECL_PRE(termp_in);
143: DECL_PRE(termp_ms);
1.10 kristaps 144: DECL_PRE(termp_nd);
1.18 kristaps 145: DECL_PRE(termp_nm);
1.10 kristaps 146: DECL_PRE(termp_ns);
147: DECL_PRE(termp_nx);
148: DECL_PRE(termp_ox);
1.18 kristaps 149: DECL_PRE(termp_pa);
1.10 kristaps 150: DECL_PRE(termp_pp);
1.14 kristaps 151: DECL_PRE(termp_rv);
1.22 ! kristaps 152: DECL_PRE(termp_sm);
1.14 kristaps 153: DECL_PRE(termp_st);
1.18 kristaps 154: DECL_PRE(termp_sx);
155: DECL_PRE(termp_sy);
1.10 kristaps 156: DECL_PRE(termp_ud);
1.16 kristaps 157: DECL_PRE(termp_ux);
1.18 kristaps 158: DECL_PRE(termp_va);
1.10 kristaps 159: DECL_PRE(termp_xr);
160:
161: DECL_POST(termp_bl);
162:
163: const struct termact __termacts[MDOC_MAX] = {
164: { NULL, NULL }, /* \" */
165: { NULL, NULL }, /* Dd */
166: { NULL, NULL }, /* Dt */
167: { NULL, NULL }, /* Os */
168: { termp_sh_pre, termp_sh_post }, /* Sh */
169: { termp_ss_pre, termp_ss_post }, /* Ss */
170: { termp_pp_pre, NULL }, /* Pp */
171: { termp_d1_pre, termp_d1_post }, /* D1 */
172: { NULL, NULL }, /* Dl */
1.12 kristaps 173: { termp_bd_pre, termp_bd_post }, /* Bd */
1.10 kristaps 174: { NULL, NULL }, /* Ed */
175: { NULL, termp_bl_post }, /* Bl */
176: { NULL, NULL }, /* El */
177: { termp_it_pre, termp_it_post }, /* It */
178: { NULL, NULL }, /* Ad */
179: { NULL, NULL }, /* An */
1.18 kristaps 180: { termp_ar_pre, NULL }, /* Ar */
181: { termp_cd_pre, NULL }, /* Cd */
182: { termp_cm_pre, NULL }, /* Cm */
1.10 kristaps 183: { NULL, NULL }, /* Dv */
184: { NULL, NULL }, /* Er */
185: { NULL, NULL }, /* Ev */
186: { termp_ex_pre, NULL }, /* Ex */
1.18 kristaps 187: { termp_fa_pre, NULL }, /* Fa */
1.10 kristaps 188: { termp_fd_pre, termp_fd_post }, /* Fd */
1.18 kristaps 189: { termp_fl_pre, NULL }, /* Fl */
1.10 kristaps 190: { termp_fn_pre, termp_fn_post }, /* Fn */
191: { termp_ft_pre, termp_ft_post }, /* Ft */
1.18 kristaps 192: { termp_ic_pre, NULL }, /* Ic */
193: { termp_in_pre, NULL }, /* In */
1.10 kristaps 194: { NULL, NULL }, /* Li */
195: { termp_nd_pre, NULL }, /* Nd */
1.18 kristaps 196: { termp_nm_pre, NULL }, /* Nm */
1.10 kristaps 197: { termp_op_pre, termp_op_post }, /* Op */
198: { NULL, NULL }, /* Ot */
1.18 kristaps 199: { termp_pa_pre, NULL }, /* Pa */
1.14 kristaps 200: { termp_rv_pre, NULL }, /* Rv */
201: { termp_st_pre, NULL }, /* St */
1.18 kristaps 202: { termp_va_pre, NULL }, /* Va */
1.10 kristaps 203: { termp_vt_pre, termp_vt_post }, /* Vt */
204: { termp_xr_pre, NULL }, /* Xr */
205: { NULL, NULL }, /* %A */
206: { NULL, NULL }, /* %B */
207: { NULL, NULL }, /* %D */
208: { NULL, NULL }, /* %I */
209: { NULL, NULL }, /* %J */
210: { NULL, NULL }, /* %N */
211: { NULL, NULL }, /* %O */
212: { NULL, NULL }, /* %P */
213: { NULL, NULL }, /* %R */
214: { NULL, NULL }, /* %T */
215: { NULL, NULL }, /* %V */
216: { NULL, NULL }, /* Ac */
1.14 kristaps 217: { termp_aq_pre, termp_aq_post }, /* Ao */
1.10 kristaps 218: { termp_aq_pre, termp_aq_post }, /* Aq */
1.14 kristaps 219: { termp_at_pre, NULL }, /* At */
1.10 kristaps 220: { NULL, NULL }, /* Bc */
1.18 kristaps 221: { termp_bf_pre, NULL }, /* Bf */
1.15 kristaps 222: { termp_bq_pre, termp_bq_post }, /* Bo */
223: { termp_bq_pre, termp_bq_post }, /* Bq */
224: { termp_bsx_pre, NULL }, /* Bsx */
1.10 kristaps 225: { termp_bx_pre, NULL }, /* Bx */
226: { NULL, NULL }, /* Db */
227: { NULL, NULL }, /* Dc */
1.15 kristaps 228: { termp_dq_pre, termp_dq_post }, /* Do */
1.10 kristaps 229: { termp_dq_pre, termp_dq_post }, /* Dq */
230: { NULL, NULL }, /* Ec */
231: { NULL, NULL }, /* Ef */
1.18 kristaps 232: { termp_em_pre, NULL }, /* Em */
1.10 kristaps 233: { NULL, NULL }, /* Eo */
1.16 kristaps 234: { termp_fx_pre, NULL }, /* Fx */
1.18 kristaps 235: { termp_ms_pre, NULL }, /* Ms */
1.10 kristaps 236: { NULL, NULL }, /* No */
237: { termp_ns_pre, NULL }, /* Ns */
238: { termp_nx_pre, NULL }, /* Nx */
239: { termp_ox_pre, NULL }, /* Ox */
240: { NULL, NULL }, /* Pc */
241: { termp_pf_pre, termp_pf_post }, /* Pf */
1.15 kristaps 242: { termp_pq_pre, termp_pq_post }, /* Po */
243: { termp_pq_pre, termp_pq_post }, /* Pq */
1.10 kristaps 244: { NULL, NULL }, /* Qc */
1.16 kristaps 245: { termp_sq_pre, termp_sq_post }, /* Ql */
1.15 kristaps 246: { termp_qq_pre, termp_qq_post }, /* Qo */
1.10 kristaps 247: { termp_qq_pre, termp_qq_post }, /* Qq */
248: { NULL, NULL }, /* Re */
249: { NULL, NULL }, /* Rs */
250: { NULL, NULL }, /* Sc */
1.15 kristaps 251: { termp_sq_pre, termp_sq_post }, /* So */
1.10 kristaps 252: { termp_sq_pre, termp_sq_post }, /* Sq */
1.22 ! kristaps 253: { termp_sm_pre, NULL }, /* Sm */
1.18 kristaps 254: { termp_sx_pre, NULL }, /* Sx */
255: { termp_sy_pre, NULL }, /* Sy */
1.10 kristaps 256: { NULL, NULL }, /* Tn */
1.16 kristaps 257: { termp_ux_pre, NULL }, /* Ux */
1.10 kristaps 258: { NULL, NULL }, /* Xc */
259: { NULL, NULL }, /* Xo */
1.16 kristaps 260: { termp_fo_pre, termp_fo_post }, /* Fo */
1.10 kristaps 261: { NULL, NULL }, /* Fc */
1.16 kristaps 262: { termp_op_pre, termp_op_post }, /* Oo */
1.10 kristaps 263: { NULL, NULL }, /* Oc */
264: { NULL, NULL }, /* Bk */
265: { NULL, NULL }, /* Ek */
1.17 kristaps 266: { termp_bt_pre, NULL }, /* Bt */
1.10 kristaps 267: { NULL, NULL }, /* Hf */
268: { NULL, NULL }, /* Fr */
269: { termp_ud_pre, NULL }, /* Ud */
1.2 kristaps 270: };
271:
1.10 kristaps 272: const struct termact *termacts = __termacts;
273:
274:
275: static size_t
1.12 kristaps 276: arg_width(const struct mdoc_arg *arg)
1.10 kristaps 277: {
1.12 kristaps 278:
279: /* TODO */
280: assert(*arg->value);
281: return(strlen(*arg->value));
282: }
283:
284:
285: static size_t
286: arg_offset(const struct mdoc_arg *arg)
287: {
288:
289: /* TODO */
290: assert(*arg->value);
291: if (0 == strcmp(*arg->value, "indent"))
1.10 kristaps 292: return(INDENT);
1.12 kristaps 293: if (0 == strcmp(*arg->value, "indent-two"))
1.10 kristaps 294: return(INDENT * 2);
295:
1.12 kristaps 296: return(strlen(*arg->value));
1.10 kristaps 297: }
298:
1.3 kristaps 299:
1.10 kristaps 300: static int
301: arg_hasattr(int arg, size_t argc, const struct mdoc_arg *argv)
1.2 kristaps 302: {
303:
1.10 kristaps 304: return(-1 != arg_getattr(arg, argc, argv));
305: }
306:
307:
308: static int
309: arg_getattr(int arg, size_t argc, const struct mdoc_arg *argv)
310: {
311: int i;
312:
313: for (i = 0; i < (int)argc; i++)
314: if (argv[i].arg == arg)
315: return(i);
316: return(-1);
317: }
318:
319:
320: /* ARGSUSED */
321: static int
322: termp_dq_pre(DECL_ARGS)
323: {
324:
325: if (MDOC_BODY != node->type)
326: return(1);
327:
328: word(p, "``");
329: p->flags |= TERMP_NOSPACE;
330: return(1);
331: }
332:
333:
334: /* ARGSUSED */
335: static void
336: termp_dq_post(DECL_ARGS)
337: {
338:
339: if (MDOC_BODY != node->type)
340: return;
1.3 kristaps 341:
1.10 kristaps 342: p->flags |= TERMP_NOSPACE;
343: word(p, "''");
344: }
1.2 kristaps 345:
1.3 kristaps 346:
1.10 kristaps 347: /* ARGSUSED */
1.20 kristaps 348: static int
349: termp_it_pre(DECL_ARGS)
1.10 kristaps 350: {
351: const struct mdoc_node *n, *it;
352: const struct mdoc_block *bl;
1.21 kristaps 353: char buf[7];
1.10 kristaps 354: int i;
1.12 kristaps 355: size_t width, offset;
1.2 kristaps 356:
1.10 kristaps 357: switch (node->type) {
358: case (MDOC_BODY):
359: /* FALLTHROUGH */
360: case (MDOC_HEAD):
1.20 kristaps 361: it = node->parent;
362: break;
363: case (MDOC_BLOCK):
364: it = node;
1.10 kristaps 365: break;
366: default:
1.20 kristaps 367: return(1);
1.8 kristaps 368: }
369:
1.21 kristaps 370: n = it->parent->parent;
1.10 kristaps 371: bl = &n->data.block;
372:
1.20 kristaps 373: if (MDOC_BLOCK == node->type) {
374: if (arg_hasattr(MDOC_Compact, bl->argc, bl->argv))
375: newln(p);
376: else
377: vspace(p);
378: return(1);
379: }
380:
381: pair->offset = p->offset;
382: pair->rmargin = p->rmargin;
383:
384: /* FIXME: auto-size. */
385: i = arg_getattr(MDOC_Width, bl->argc, bl->argv);
386: width = i >= 0 ? arg_width(&bl->argv[i]) : 10;
387:
388: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
389: offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;
390:
391: assert(MDOC_HEAD == node->type ||
392: MDOC_BODY == node->type);
1.10 kristaps 393:
394: if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) {
1.20 kristaps 395: p->flags |= TERMP_NOSPACE;
1.21 kristaps 396: if (MDOC_BODY == node->type) {
397: p->flags |= TERMP_NOLPAD;
398: p->offset += width;
399: } else {
400: p->flags |= TERMP_NOBREAK;
401: p->rmargin = p->offset + offset + width;
402: }
1.10 kristaps 403:
1.21 kristaps 404: } else if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) {
405: p->flags |= TERMP_NOSPACE;
406:
407: } else if (arg_hasattr(MDOC_Diag, bl->argc, bl->argv)) {
408: /* TODO. */
409:
410: } else if (arg_hasattr(MDOC_Hang, bl->argc, bl->argv)) {
411: /* TODO. */
412:
413: } else if (arg_hasattr(MDOC_Bullet, bl->argc, bl->argv)) {
414: p->flags |= TERMP_NOSPACE;
415: if (MDOC_BODY == node->type) {
416: p->flags |= TERMP_NOLPAD;
417: p->offset += 6;
418: } else {
419: word(p, "\\[bu]");
1.20 kristaps 420: p->flags |= TERMP_NOBREAK;
1.21 kristaps 421: p->rmargin = p->offset + offset + 6;
422: }
423:
424: } else if (arg_hasattr(MDOC_Enum, bl->argc, bl->argv)) {
425: p->flags |= TERMP_NOSPACE;
426: if (MDOC_BODY == node->type) {
427: p->flags |= TERMP_NOLPAD;
428: p->offset += 6;
1.10 kristaps 429: } else {
1.21 kristaps 430: (pair->ppair->ppair->count)++;
431: (void)snprintf(buf, sizeof(buf), "%d.",
432: pair->ppair->ppair->count);
433: word(p, buf);
434: p->flags |= TERMP_NOBREAK;
435: p->rmargin = p->offset + offset + 6;
1.2 kristaps 436: }
1.20 kristaps 437:
1.21 kristaps 438: } else if (arg_hasattr(MDOC_Dash, bl->argc, bl->argv) ||
439: arg_hasattr(MDOC_Hyphen, bl->argc, bl->argv)) {
1.20 kristaps 440: p->flags |= TERMP_NOSPACE;
1.21 kristaps 441: if (MDOC_BODY == node->type) {
442: p->flags |= TERMP_NOLPAD;
443: p->offset += 6;
444: return(1);
445: } else {
446: word(p, "\\-");
447: p->flags |= TERMP_NOBREAK;
448: p->rmargin = p->offset + offset + 6;
449: }
450: }
1.2 kristaps 451:
1.21 kristaps 452: p->offset += offset;
1.20 kristaps 453: return(1);
1.10 kristaps 454: }
455:
456:
457: /* ARGSUSED */
1.20 kristaps 458: static void
459: termp_it_post(DECL_ARGS)
1.10 kristaps 460: {
461: const struct mdoc_node *n, *it;
462: const struct mdoc_block *bl;
1.3 kristaps 463:
1.21 kristaps 464: if (MDOC_BODY != node->type && MDOC_HEAD != node->type)
1.20 kristaps 465: return;
1.10 kristaps 466:
1.20 kristaps 467: it = node->parent;
1.21 kristaps 468: n = it->parent->parent;
1.10 kristaps 469: bl = &n->data.block;
470:
1.21 kristaps 471: if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv) ||
472: arg_hasattr(MDOC_Bullet, bl->argc, bl->argv) ||
473: arg_hasattr(MDOC_Dash, bl->argc, bl->argv) ||
474: arg_hasattr(MDOC_Enum, bl->argc, bl->argv) ||
475: arg_hasattr(MDOC_Hyphen, bl->argc, bl->argv)) {
1.20 kristaps 476: flushln(p);
1.10 kristaps 477: if (MDOC_HEAD == node->type) {
1.20 kristaps 478: p->rmargin = pair->rmargin;
479: p->flags &= ~TERMP_NOBREAK;
1.21 kristaps 480: } else
1.20 kristaps 481: p->flags &= ~TERMP_NOLPAD;
1.10 kristaps 482:
1.20 kristaps 483: } else if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) {
484: flushln(p);
1.21 kristaps 485:
486: } else if (arg_hasattr(MDOC_Inset, bl->argc, bl->argv)) {
487: if (MDOC_BODY == node->type)
488: flushln(p);
489:
490: } else if (arg_hasattr(MDOC_Item, bl->argc, bl->argv)) {
491: if (MDOC_BODY == node->type)
492: flushln(p);
1.10 kristaps 493: }
1.21 kristaps 494:
495: p->offset = pair->offset;
1.2 kristaps 496: }
497:
498:
1.10 kristaps 499: /* ARGSUSED */
1.18 kristaps 500: static int
501: termp_nm_pre(DECL_ARGS)
1.10 kristaps 502: {
503:
1.18 kristaps 504: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_PROG]);
505: if (NULL == node->child)
506: word(p, meta->name);
507: return(1);
1.10 kristaps 508: }
509:
510:
511: /* ARGSUSED */
1.18 kristaps 512: static int
513: termp_fl_pre(DECL_ARGS)
1.10 kristaps 514: {
515:
1.18 kristaps 516: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]);
517: word(p, "\\-");
518: p->flags |= TERMP_NOSPACE;
519: return(1);
1.10 kristaps 520: }
521:
522:
523: /* ARGSUSED */
524: static int
525: termp_ar_pre(DECL_ARGS)
526: {
527:
1.18 kristaps 528: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_ARG]);
1.10 kristaps 529: if (NULL == node->child)
530: word(p, "...");
531: return(1);
532: }
533:
534:
535: /* ARGSUSED */
536: static int
537: termp_ns_pre(DECL_ARGS)
1.2 kristaps 538: {
539:
540: p->flags |= TERMP_NOSPACE;
1.10 kristaps 541: return(1);
542: }
543:
544:
545: /* ARGSUSED */
546: static int
547: termp_pp_pre(DECL_ARGS)
548: {
549:
550: vspace(p);
551: return(1);
552: }
553:
554:
555: /* ARGSUSED */
556: static int
1.14 kristaps 557: termp_st_pre(DECL_ARGS)
558: {
559: const char *tp;
560:
561: assert(1 == node->data.elem.argc);
562:
563: tp = mdoc_st2a(node->data.elem.argv[0].arg);
564: word(p, tp);
565:
566: return(1);
567: }
568:
569:
570: /* ARGSUSED */
571: static int
572: termp_rv_pre(DECL_ARGS)
573: {
574: int i;
575:
576: i = arg_getattr(MDOC_Std, node->data.elem.argc,
577: node->data.elem.argv);
578: assert(i >= 0);
579:
580: newln(p);
581: word(p, "The");
582:
583: p->flags |= ttypes[TTYPE_FUNC_NAME];
584: word(p, *node->data.elem.argv[i].value);
585: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
586:
587: word(p, "() function returns the value 0 if successful;");
588: word(p, "otherwise the value -1 is returned and the");
589: word(p, "global variable");
590:
591: p->flags |= ttypes[TTYPE_VAR_DECL];
592: word(p, "errno");
593: p->flags &= ~ttypes[TTYPE_VAR_DECL];
594:
595: word(p, "is set to indicate the error.");
596:
597: return(1);
598: }
599:
600:
601: /* ARGSUSED */
602: static int
1.10 kristaps 603: termp_ex_pre(DECL_ARGS)
604: {
605: int i;
606:
607: i = arg_getattr(MDOC_Std, node->data.elem.argc,
608: node->data.elem.argv);
609: assert(i >= 0);
610:
611: word(p, "The");
612: p->flags |= ttypes[TTYPE_PROG];
613: word(p, *node->data.elem.argv[i].value);
614: p->flags &= ~ttypes[TTYPE_PROG];
615: word(p, "utility exits 0 on success, and >0 if an error occurs.");
616:
617: return(1);
618: }
619:
620:
621: /* ARGSUSED */
622: static int
623: termp_nd_pre(DECL_ARGS)
624: {
625:
626: word(p, "\\-");
627: return(1);
628: }
629:
630:
631: /* ARGSUSED */
632: static void
633: termp_bl_post(DECL_ARGS)
634: {
635:
636: if (MDOC_BLOCK == node->type)
637: newln(p);
638: }
639:
640:
641: /* ARGSUSED */
642: static void
643: termp_op_post(DECL_ARGS)
644: {
645:
646: if (MDOC_BODY != node->type)
1.2 kristaps 647: return;
1.10 kristaps 648: p->flags |= TERMP_NOSPACE;
649: word(p, "\\(rB");
650: }
651:
652:
653: /* ARGSUSED */
654: static int
655: termp_xr_pre(DECL_ARGS)
656: {
657: const struct mdoc_node *n;
658:
659: n = node->child;
660: assert(n);
661:
662: assert(MDOC_TEXT == n->type);
663: word(p, n->data.text.string);
664:
665: if (NULL == (n = n->next))
666: return(0);
667:
668: assert(MDOC_TEXT == n->type);
669: p->flags |= TERMP_NOSPACE;
670: word(p, "(");
671: p->flags |= TERMP_NOSPACE;
672: word(p, n->data.text.string);
673: p->flags |= TERMP_NOSPACE;
674: word(p, ")");
675:
676: return(0);
1.2 kristaps 677: }
678:
679:
1.10 kristaps 680: /* ARGSUSED */
681: static int
682: termp_vt_pre(DECL_ARGS)
1.2 kristaps 683: {
684:
1.10 kristaps 685: /* FIXME: this can be "type name". */
1.18 kristaps 686: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]);
1.10 kristaps 687: return(1);
1.2 kristaps 688: }
689:
690:
1.10 kristaps 691: /* ARGSUSED */
1.2 kristaps 692: static void
1.10 kristaps 693: termp_vt_post(DECL_ARGS)
694: {
695:
696: if (node->sec == SEC_SYNOPSIS)
697: vspace(p);
698: }
699:
700:
701: /* ARGSUSED */
702: static int
703: termp_fd_pre(DECL_ARGS)
1.2 kristaps 704: {
705:
1.10 kristaps 706: /*
707: * FIXME: this naming is bad. This value is used, in general,
708: * for the #include header or other preprocessor statement.
709: */
1.18 kristaps 710: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_DECL]);
1.10 kristaps 711: return(1);
1.2 kristaps 712: }
713:
714:
1.10 kristaps 715: /* ARGSUSED */
1.2 kristaps 716: static void
1.10 kristaps 717: termp_fd_post(DECL_ARGS)
1.2 kristaps 718: {
719:
1.10 kristaps 720: if (node->sec == SEC_SYNOPSIS)
721: vspace(p);
722: }
723:
724:
725: /* ARGSUSED */
726: static int
727: termp_sh_pre(DECL_ARGS)
728: {
1.2 kristaps 729:
1.10 kristaps 730: switch (node->type) {
731: case (MDOC_HEAD):
732: vspace(p);
1.18 kristaps 733: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SECTION]);
1.2 kristaps 734: break;
1.10 kristaps 735: case (MDOC_BODY):
736: p->offset = INDENT;
1.2 kristaps 737: break;
1.10 kristaps 738: default:
739: break;
740: }
741: return(1);
742: }
743:
744:
745: /* ARGSUSED */
1.19 kristaps 746: static void
747: termp_sh_post(DECL_ARGS)
748: {
749:
750: switch (node->type) {
751: case (MDOC_HEAD):
752: newln(p);
753: break;
754: case (MDOC_BODY):
755: newln(p);
756: p->offset = 0;
757: break;
758: default:
759: break;
760: }
761: }
762:
763:
764: /* ARGSUSED */
1.10 kristaps 765: static int
766: termp_op_pre(DECL_ARGS)
767: {
768:
769: switch (node->type) {
770: case (MDOC_BODY):
771: word(p, "\\(lB");
772: p->flags |= TERMP_NOSPACE;
1.2 kristaps 773: break;
774: default:
1.10 kristaps 775: break;
1.2 kristaps 776: }
1.10 kristaps 777: return(1);
778: }
779:
780:
781: /* ARGSUSED */
782: static int
1.17 kristaps 783: termp_bt_pre(DECL_ARGS)
784: {
785:
786: word(p, "is currently in beta test.");
787: return(1);
788: }
789:
790:
791: /* ARGSUSED */
792: static int
1.10 kristaps 793: termp_ud_pre(DECL_ARGS)
794: {
795:
796: word(p, "currently under development.");
797: return(1);
798: }
799:
800:
801: /* ARGSUSED */
802: static int
803: termp_d1_pre(DECL_ARGS)
804: {
805:
806: if (MDOC_BODY != node->type)
807: return(1);
808: newln(p);
1.19 kristaps 809: p->offset += (pair->offset = INDENT);
1.10 kristaps 810: return(1);
1.2 kristaps 811: }
812:
813:
1.10 kristaps 814: /* ARGSUSED */
1.2 kristaps 815: static void
1.10 kristaps 816: termp_d1_post(DECL_ARGS)
817: {
818:
819: if (MDOC_BODY != node->type)
820: return;
821: newln(p);
1.19 kristaps 822: p->offset -= pair->offset;
1.10 kristaps 823: }
824:
825:
826: /* ARGSUSED */
827: static int
828: termp_aq_pre(DECL_ARGS)
1.6 kristaps 829: {
830:
1.10 kristaps 831: if (MDOC_BODY != node->type)
832: return(1);
833: word(p, "<");
834: p->flags |= TERMP_NOSPACE;
835: return(1);
836: }
1.6 kristaps 837:
838:
1.10 kristaps 839: /* ARGSUSED */
840: static void
841: termp_aq_post(DECL_ARGS)
842: {
1.6 kristaps 843:
1.10 kristaps 844: if (MDOC_BODY != node->type)
1.6 kristaps 845: return;
1.10 kristaps 846: p->flags |= TERMP_NOSPACE;
847: word(p, ">");
848: }
1.6 kristaps 849:
1.10 kristaps 850:
851: /* ARGSUSED */
852: static int
853: termp_ft_pre(DECL_ARGS)
854: {
855:
1.18 kristaps 856: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_TYPE]);
1.10 kristaps 857: return(1);
1.6 kristaps 858: }
859:
860:
1.10 kristaps 861: /* ARGSUSED */
1.6 kristaps 862: static void
1.10 kristaps 863: termp_ft_post(DECL_ARGS)
1.2 kristaps 864: {
865:
1.10 kristaps 866: if (node->sec == SEC_SYNOPSIS)
867: newln(p);
868: }
1.2 kristaps 869:
870:
1.10 kristaps 871: /* ARGSUSED */
872: static int
873: termp_fn_pre(DECL_ARGS)
874: {
875: const struct mdoc_node *n;
876:
877: assert(node->child);
878: assert(MDOC_TEXT == node->child->type);
1.2 kristaps 879:
1.10 kristaps 880: /* FIXME: can be "type funcname" "type varname"... */
1.2 kristaps 881:
1.10 kristaps 882: p->flags |= ttypes[TTYPE_FUNC_NAME];
883: word(p, node->child->data.text.string);
884: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
885:
886: word(p, "(");
887:
888: p->flags |= TERMP_NOSPACE;
889: for (n = node->child->next; n; n = n->next) {
890: assert(MDOC_TEXT == n->type);
891: p->flags |= ttypes[TTYPE_FUNC_ARG];
892: word(p, n->data.text.string);
893: p->flags &= ~ttypes[TTYPE_FUNC_ARG];
1.16 kristaps 894: if (n->next)
1.10 kristaps 895: word(p, ",");
1.6 kristaps 896: }
1.2 kristaps 897:
1.10 kristaps 898: word(p, ")");
899:
900: if (SEC_SYNOPSIS == node->sec)
901: word(p, ";");
902:
903: return(0);
1.2 kristaps 904: }
905:
906:
1.10 kristaps 907: /* ARGSUSED */
908: static void
909: termp_fn_post(DECL_ARGS)
1.2 kristaps 910: {
911:
1.10 kristaps 912: if (node->sec == SEC_SYNOPSIS)
913: vspace(p);
914:
915: }
1.2 kristaps 916:
917:
1.10 kristaps 918: /* ARGSUSED */
919: static int
920: termp_sx_pre(DECL_ARGS)
921: {
1.8 kristaps 922:
1.18 kristaps 923: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_LINK]);
1.10 kristaps 924: return(1);
1.2 kristaps 925: }
926:
927:
1.10 kristaps 928: /* ARGSUSED */
929: static int
930: termp_fa_pre(DECL_ARGS)
931: {
1.16 kristaps 932: struct mdoc_node *n;
933:
934: if (node->parent->tok != MDOC_Fo) {
1.18 kristaps 935: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_ARG]);
1.16 kristaps 936: return(1);
937: }
938:
939: for (n = node->child; n; n = n->next) {
940: assert(MDOC_TEXT == n->type);
941:
942: p->flags |= ttypes[TTYPE_FUNC_ARG];
943: word(p, n->data.text.string);
944: p->flags &= ~ttypes[TTYPE_FUNC_ARG];
945:
946: if (n->next)
947: word(p, ",");
948: }
949:
950: if (node->next && node->next->tok == MDOC_Fa)
951: word(p, ",");
1.2 kristaps 952:
1.16 kristaps 953: return(0);
1.10 kristaps 954: }
1.2 kristaps 955:
956:
1.10 kristaps 957: /* ARGSUSED */
958: static int
959: termp_va_pre(DECL_ARGS)
960: {
1.2 kristaps 961:
1.18 kristaps 962: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]);
1.10 kristaps 963: return(1);
1.2 kristaps 964: }
965:
966:
1.10 kristaps 967: /* ARGSUSED */
968: static int
969: termp_bd_pre(DECL_ARGS)
970: {
971: const struct mdoc_block *bl;
972: const struct mdoc_node *n;
1.12 kristaps 973: int i;
1.1 kristaps 974:
1.10 kristaps 975: if (MDOC_BLOCK == node->type) {
976: vspace(p);
977: return(1);
978: } else if (MDOC_BODY != node->type)
979: return(1);
980:
981: assert(MDOC_BLOCK == node->parent->type);
1.20 kristaps 982: pair->offset = p->offset;
1.10 kristaps 983:
984: bl = &node->parent->data.block;
1.12 kristaps 985:
1.20 kristaps 986:
1.12 kristaps 987: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
988: if (-1 != i) {
989: assert(1 == bl->argv[i].sz);
1.20 kristaps 990: p->offset += arg_offset(&bl->argv[i]);
1.12 kristaps 991: }
992:
1.10 kristaps 993: if ( ! arg_hasattr(MDOC_Literal, bl->argc, bl->argv))
994: return(1);
995:
996: p->flags |= TERMP_LITERAL;
997:
998: for (n = node->child; n; n = n->next) {
999: assert(MDOC_TEXT == n->type); /* FIXME */
1000: if ((*n->data.text.string)) {
1001: word(p, n->data.text.string);
1002: flushln(p);
1003: } else
1004: vspace(p);
1.1 kristaps 1005:
1.10 kristaps 1006: }
1.1 kristaps 1007:
1.10 kristaps 1008: p->flags &= ~TERMP_LITERAL;
1009: return(0);
1010: }
1.1 kristaps 1011:
1012:
1.10 kristaps 1013: /* ARGSUSED */
1.12 kristaps 1014: static void
1015: termp_bd_post(DECL_ARGS)
1016: {
1017:
1.20 kristaps 1018: if (MDOC_BODY != node->type)
1019: return;
1020: newln(p);
1021: p->offset = pair->offset;
1.12 kristaps 1022: }
1023:
1024:
1025: /* ARGSUSED */
1.10 kristaps 1026: static int
1027: termp_qq_pre(DECL_ARGS)
1028: {
1.1 kristaps 1029:
1.10 kristaps 1030: if (MDOC_BODY != node->type)
1031: return(1);
1032: word(p, "\"");
1033: p->flags |= TERMP_NOSPACE;
1034: return(1);
1.1 kristaps 1035: }
1036:
1037:
1.10 kristaps 1038: /* ARGSUSED */
1.1 kristaps 1039: static void
1.10 kristaps 1040: termp_qq_post(DECL_ARGS)
1.1 kristaps 1041: {
1042:
1.10 kristaps 1043: if (MDOC_BODY != node->type)
1044: return;
1045: p->flags |= TERMP_NOSPACE;
1046: word(p, "\"");
1047: }
1048:
1049:
1050: /* ARGSUSED */
1051: static int
1.15 kristaps 1052: termp_bsx_pre(DECL_ARGS)
1053: {
1054:
1055: word(p, "BSDI BSD/OS");
1056: return(1);
1057: }
1058:
1059:
1060: /* ARGSUSED */
1061: static int
1.10 kristaps 1062: termp_bx_pre(DECL_ARGS)
1063: {
1.1 kristaps 1064:
1.10 kristaps 1065: word(p, "BSD");
1066: return(1);
1067: }
1068:
1069:
1070: /* ARGSUSED */
1071: static int
1072: termp_ox_pre(DECL_ARGS)
1073: {
1074:
1075: word(p, "OpenBSD");
1076: return(1);
1077: }
1078:
1079:
1080: /* ARGSUSED */
1081: static int
1.16 kristaps 1082: termp_ux_pre(DECL_ARGS)
1083: {
1084:
1085: word(p, "UNIX");
1086: return(1);
1087: }
1088:
1089:
1090: /* ARGSUSED */
1091: static int
1092: termp_fx_pre(DECL_ARGS)
1093: {
1094:
1095: word(p, "FreeBSD");
1096: return(1);
1097: }
1098:
1099:
1100: /* ARGSUSED */
1101: static int
1.10 kristaps 1102: termp_nx_pre(DECL_ARGS)
1103: {
1104:
1105: word(p, "NetBSD");
1106: return(1);
1107: }
1108:
1109:
1110: /* ARGSUSED */
1111: static int
1112: termp_sq_pre(DECL_ARGS)
1113: {
1114:
1115: if (MDOC_BODY != node->type)
1116: return(1);
1.13 kristaps 1117: word(p, "\'");
1.10 kristaps 1118: p->flags |= TERMP_NOSPACE;
1119: return(1);
1120: }
1.1 kristaps 1121:
1122:
1.10 kristaps 1123: /* ARGSUSED */
1124: static void
1125: termp_sq_post(DECL_ARGS)
1126: {
1127:
1128: if (MDOC_BODY != node->type)
1129: return;
1130: p->flags |= TERMP_NOSPACE;
1131: word(p, "\'");
1132: }
1.2 kristaps 1133:
1134:
1.10 kristaps 1135: /* ARGSUSED */
1136: static int
1137: termp_pf_pre(DECL_ARGS)
1138: {
1.1 kristaps 1139:
1.10 kristaps 1140: p->flags |= TERMP_IGNDELIM;
1141: return(1);
1142: }
1.1 kristaps 1143:
1144:
1.10 kristaps 1145: /* ARGSUSED */
1146: static void
1147: termp_pf_post(DECL_ARGS)
1148: {
1.1 kristaps 1149:
1.10 kristaps 1150: p->flags &= ~TERMP_IGNDELIM;
1151: p->flags |= TERMP_NOSPACE;
1152: }
1.1 kristaps 1153:
1154:
1.10 kristaps 1155: /* ARGSUSED */
1156: static int
1157: termp_ss_pre(DECL_ARGS)
1158: {
1.1 kristaps 1159:
1.10 kristaps 1160: switch (node->type) {
1161: case (MDOC_HEAD):
1162: vspace(p);
1.18 kristaps 1163: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SSECTION]);
1.10 kristaps 1164: p->offset = INDENT / 2;
1165: break;
1166: default:
1167: break;
1168: }
1.1 kristaps 1169:
1.10 kristaps 1170: return(1);
1.1 kristaps 1171: }
1172:
1173:
1.10 kristaps 1174: /* ARGSUSED */
1175: static void
1176: termp_ss_post(DECL_ARGS)
1.1 kristaps 1177: {
1178:
1.10 kristaps 1179: switch (node->type) {
1180: case (MDOC_HEAD):
1181: newln(p);
1182: p->offset = INDENT;
1183: break;
1184: default:
1185: break;
1186: }
1187: }
1.2 kristaps 1188:
1189:
1.10 kristaps 1190: /* ARGSUSED */
1191: static int
1192: termp_pa_pre(DECL_ARGS)
1193: {
1.2 kristaps 1194:
1.18 kristaps 1195: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FILE]);
1.10 kristaps 1196: return(1);
1.1 kristaps 1197: }
1198:
1199:
1.10 kristaps 1200: /* ARGSUSED */
1.11 kristaps 1201: static int
1202: termp_em_pre(DECL_ARGS)
1203: {
1204:
1.18 kristaps 1205: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.11 kristaps 1206: return(1);
1207: }
1208:
1209:
1210: /* ARGSUSED */
1.14 kristaps 1211: static int
1212: termp_cd_pre(DECL_ARGS)
1213: {
1214:
1.18 kristaps 1215: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CONFIG]);
1.14 kristaps 1216: return(1);
1217: }
1218:
1219:
1220: /* ARGSUSED */
1221: static int
1222: termp_cm_pre(DECL_ARGS)
1223: {
1224:
1.18 kristaps 1225: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]);
1.14 kristaps 1226: return(1);
1227: }
1228:
1229:
1230: /* ARGSUSED */
1231: static int
1232: termp_ic_pre(DECL_ARGS)
1233: {
1234:
1.18 kristaps 1235: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD]);
1.14 kristaps 1236: return(1);
1237: }
1238:
1239:
1240: /* ARGSUSED */
1241: static int
1242: termp_in_pre(DECL_ARGS)
1243: {
1244:
1.18 kristaps 1245: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_INCLUDE]);
1.14 kristaps 1246: return(1);
1247: }
1248:
1249:
1250: /* ARGSUSED */
1251: static int
1252: termp_at_pre(DECL_ARGS)
1253: {
1254: enum mdoc_att c;
1255:
1256: c = ATT_DEFAULT;
1257: if (node->child) {
1258: assert(MDOC_TEXT == node->child->type);
1259: c = mdoc_atoatt(node->child->data.text.string);
1260: }
1261:
1262: word(p, mdoc_att2a(c));
1263: return(0);
1264: }
1.15 kristaps 1265:
1266:
1267: /* ARGSUSED */
1268: static int
1269: termp_bq_pre(DECL_ARGS)
1270: {
1271:
1272: if (MDOC_BODY != node->type)
1273: return(1);
1274: word(p, "[");
1275: p->flags |= TERMP_NOSPACE;
1276: return(1);
1277: }
1278:
1279:
1280: /* ARGSUSED */
1281: static void
1282: termp_bq_post(DECL_ARGS)
1283: {
1284:
1285: if (MDOC_BODY != node->type)
1286: return;
1287: word(p, "]");
1288: }
1289:
1290:
1291: /* ARGSUSED */
1292: static int
1293: termp_pq_pre(DECL_ARGS)
1294: {
1295:
1296: if (MDOC_BODY != node->type)
1297: return(1);
1298: word(p, "(");
1299: p->flags |= TERMP_NOSPACE;
1300: return(1);
1301: }
1302:
1303:
1304: /* ARGSUSED */
1305: static void
1306: termp_pq_post(DECL_ARGS)
1307: {
1308:
1309: if (MDOC_BODY != node->type)
1310: return;
1311: word(p, ")");
1312: }
1313:
1314:
1.16 kristaps 1315: /* ARGSUSED */
1316: static int
1317: termp_fo_pre(DECL_ARGS)
1318: {
1319: const struct mdoc_node *n;
1320:
1321: if (MDOC_BODY == node->type) {
1322: word(p, "(");
1323: p->flags |= TERMP_NOSPACE;
1324: return(1);
1325: } else if (MDOC_HEAD != node->type)
1326: return(1);
1327:
1.17 kristaps 1328: /* XXX - groff shows only first parameter */
1329:
1.16 kristaps 1330: p->flags |= ttypes[TTYPE_FUNC_NAME];
1331: for (n = node->child; n; n = n->next) {
1332: assert(MDOC_TEXT == n->type);
1333: word(p, n->data.text.string);
1334: }
1335: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
1336:
1337: return(0);
1338: }
1339:
1340:
1341: /* ARGSUSED */
1342: static void
1343: termp_fo_post(DECL_ARGS)
1344: {
1345:
1346: if (MDOC_BODY != node->type)
1347: return;
1348: word(p, ")");
1349: word(p, ";");
1350: newln(p);
1351: }
1352:
1353:
1.17 kristaps 1354: /* ARGSUSED */
1355: static int
1356: termp_bf_pre(DECL_ARGS)
1357: {
1358: const struct mdoc_node *n;
1359: const struct mdoc_block *b;
1360:
1361: /* XXX - we skip over possible trailing HEAD tokens. */
1362:
1363: if (MDOC_HEAD == node->type)
1364: return(0);
1365: else if (MDOC_BLOCK != node->type)
1366: return(1);
1367:
1368: b = &node->data.block;
1369:
1370: if (NULL == (n = b->head->child)) {
1371: if (arg_hasattr(MDOC_Emphasis, b->argc, b->argv))
1.18 kristaps 1372: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.17 kristaps 1373: else if (arg_hasattr(MDOC_Symbolic, b->argc, b->argv))
1.18 kristaps 1374: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMB]);
1.17 kristaps 1375:
1376: return(1);
1377: }
1378:
1379: assert(MDOC_TEXT == n->type);
1380:
1381: if (0 == strcmp("Em", n->data.text.string))
1.18 kristaps 1382: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.17 kristaps 1383: else if (0 == strcmp("Sy", n->data.text.string))
1.18 kristaps 1384: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_EMPH]);
1.17 kristaps 1385:
1386: return(1);
1387: }
1388:
1389:
1390: /* ARGSUSED */
1391: static int
1392: termp_sy_pre(DECL_ARGS)
1393: {
1394:
1.18 kristaps 1395: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMB]);
1.17 kristaps 1396: return(1);
1397: }
1398:
1399:
1400: /* ARGSUSED */
1401: static int
1402: termp_ms_pre(DECL_ARGS)
1403: {
1404:
1.18 kristaps 1405: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SYMBOL]);
1.17 kristaps 1406: return(1);
1407: }
1408:
1.22 ! kristaps 1409:
! 1410:
! 1411: /* ARGSUSED */
! 1412: static int
! 1413: termp_sm_pre(DECL_ARGS)
! 1414: {
! 1415:
! 1416: #if notyet
! 1417: assert(node->child);
! 1418: if (0 == strcmp("off", node->child->data.text.string)) {
! 1419: p->flags &= ~TERMP_NONOSPACE;
! 1420: p->flags &= ~TERMP_NOSPACE;
! 1421: } else {
! 1422: p->flags |= TERMP_NONOSPACE;
! 1423: p->flags |= TERMP_NOSPACE;
! 1424: }
! 1425: #endif
! 1426:
! 1427: return(0);
! 1428: }
CVSweb