Annotation of mandoc/term.c, Revision 1.19
1.19 ! kristaps 1: /* $Id: term.c,v 1.18 2009/02/25 12:09:20 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>
20: #include <stdlib.h>
21: #include <string.h>
22:
1.10 kristaps 23: #include "term.h"
24:
25: #define INDENT 4
26:
27: /*
28: * Performs actions on nodes of the abstract syntax tree. Both pre- and
29: * post-fix operations are defined here.
30: */
31:
32: /* FIXME: indent/tab. */
1.12 kristaps 33: /* FIXME: handle nested lists. */
1.10 kristaps 34:
35: #define TTYPE_PROG 0
36: #define TTYPE_CMD_FLAG 1
37: #define TTYPE_CMD_ARG 2
38: #define TTYPE_SECTION 3
39: #define TTYPE_FUNC_DECL 4
40: #define TTYPE_VAR_DECL 5
41: #define TTYPE_FUNC_TYPE 6
42: #define TTYPE_FUNC_NAME 7
43: #define TTYPE_FUNC_ARG 8
44: #define TTYPE_LINK 9
45: #define TTYPE_SSECTION 10
46: #define TTYPE_FILE 11
1.11 kristaps 47: #define TTYPE_EMPH 12
1.14 kristaps 48: #define TTYPE_CONFIG 13
49: #define TTYPE_CMD 14
50: #define TTYPE_INCLUDE 15
1.17 kristaps 51: #define TTYPE_SYMB 16
52: #define TTYPE_SYMBOL 17
53: #define TTYPE_NMAX 18
1.10 kristaps 54:
55: /*
56: * These define "styles" for element types, like command arguments or
57: * executable names. This is useful when multiple macros must decorate
58: * the same thing (like .Ex -std cmd and .Nm cmd).
59: */
60:
61: const int ttypes[TTYPE_NMAX] = {
62: TERMP_BOLD, /* TTYPE_PROG */
63: TERMP_BOLD, /* TTYPE_CMD_FLAG */
64: TERMP_UNDERLINE, /* TTYPE_CMD_ARG */
65: TERMP_BOLD, /* TTYPE_SECTION */
66: TERMP_BOLD, /* TTYPE_FUNC_DECL */
67: TERMP_UNDERLINE, /* TTYPE_VAR_DECL */
68: TERMP_UNDERLINE, /* TTYPE_FUNC_TYPE */
69: TERMP_BOLD, /* TTYPE_FUNC_NAME */
70: TERMP_UNDERLINE, /* TTYPE_FUNC_ARG */
71: TERMP_UNDERLINE, /* TTYPE_LINK */
72: TERMP_BOLD, /* TTYPE_SSECTION */
1.11 kristaps 73: TERMP_UNDERLINE, /* TTYPE_FILE */
1.14 kristaps 74: TERMP_UNDERLINE, /* TTYPE_EMPH */
75: TERMP_BOLD, /* TTYPE_CONFIG */
76: TERMP_BOLD, /* TTYPE_CMD */
1.17 kristaps 77: TERMP_BOLD, /* TTYPE_INCLUDE */
78: TERMP_BOLD, /* TTYPE_SYMB */
79: TERMP_BOLD /* TTYPE_SYMBOL */
1.10 kristaps 80: };
1.7 kristaps 81:
1.10 kristaps 82: static int arg_hasattr(int, size_t,
83: const struct mdoc_arg *);
84: static int arg_getattr(int, size_t,
85: const struct mdoc_arg *);
1.12 kristaps 86: static size_t arg_offset(const struct mdoc_arg *);
87: static size_t arg_width(const struct mdoc_arg *);
1.10 kristaps 88:
89: /*
90: * What follows describes prefix and postfix operations for the abstract
91: * syntax tree descent.
92: */
1.1 kristaps 93:
1.10 kristaps 94: #define DECL_ARGS \
95: struct termp *p, \
1.18 kristaps 96: struct termpair *pair, \
1.10 kristaps 97: const struct mdoc_meta *meta, \
98: const struct mdoc_node *node
99:
100: #define DECL_PRE(name) \
101: static int name##_pre(DECL_ARGS)
102: #define DECL_POST(name) \
103: static void name##_post(DECL_ARGS)
104: #define DECL_PREPOST(name) \
105: DECL_PRE(name); \
106: DECL_POST(name);
107:
108: DECL_PREPOST(termp_aq);
1.12 kristaps 109: DECL_PREPOST(termp_bd);
1.15 kristaps 110: DECL_PREPOST(termp_bq);
1.10 kristaps 111: DECL_PREPOST(termp_d1);
112: DECL_PREPOST(termp_dq);
113: DECL_PREPOST(termp_fd);
114: DECL_PREPOST(termp_fn);
1.16 kristaps 115: DECL_PREPOST(termp_fo);
1.10 kristaps 116: DECL_PREPOST(termp_ft);
117: DECL_PREPOST(termp_it);
118: DECL_PREPOST(termp_op);
119: DECL_PREPOST(termp_pf);
1.15 kristaps 120: DECL_PREPOST(termp_pq);
1.10 kristaps 121: DECL_PREPOST(termp_qq);
122: DECL_PREPOST(termp_sh);
123: DECL_PREPOST(termp_ss);
124: DECL_PREPOST(termp_sq);
125: DECL_PREPOST(termp_vt);
126:
1.18 kristaps 127: DECL_PRE(termp_ar);
1.14 kristaps 128: DECL_PRE(termp_at);
1.18 kristaps 129: DECL_PRE(termp_bf);
1.15 kristaps 130: DECL_PRE(termp_bsx);
1.17 kristaps 131: DECL_PRE(termp_bt);
1.10 kristaps 132: DECL_PRE(termp_bx);
1.18 kristaps 133: DECL_PRE(termp_cd);
134: DECL_PRE(termp_cm);
135: DECL_PRE(termp_em);
1.10 kristaps 136: DECL_PRE(termp_ex);
1.18 kristaps 137: DECL_PRE(termp_fa);
138: DECL_PRE(termp_fl);
1.16 kristaps 139: DECL_PRE(termp_fx);
1.18 kristaps 140: DECL_PRE(termp_ic);
141: DECL_PRE(termp_in);
142: DECL_PRE(termp_ms);
1.10 kristaps 143: DECL_PRE(termp_nd);
1.18 kristaps 144: DECL_PRE(termp_nm);
1.10 kristaps 145: DECL_PRE(termp_ns);
146: DECL_PRE(termp_nx);
147: DECL_PRE(termp_ox);
1.18 kristaps 148: DECL_PRE(termp_pa);
1.10 kristaps 149: DECL_PRE(termp_pp);
1.14 kristaps 150: DECL_PRE(termp_rv);
151: DECL_PRE(termp_st);
1.18 kristaps 152: DECL_PRE(termp_sx);
153: DECL_PRE(termp_sy);
1.10 kristaps 154: DECL_PRE(termp_ud);
1.16 kristaps 155: DECL_PRE(termp_ux);
1.18 kristaps 156: DECL_PRE(termp_va);
1.10 kristaps 157: DECL_PRE(termp_xr);
158:
159: DECL_POST(termp_bl);
160:
161: const struct termact __termacts[MDOC_MAX] = {
162: { NULL, NULL }, /* \" */
163: { NULL, NULL }, /* Dd */
164: { NULL, NULL }, /* Dt */
165: { NULL, NULL }, /* Os */
166: { termp_sh_pre, termp_sh_post }, /* Sh */
167: { termp_ss_pre, termp_ss_post }, /* Ss */
168: { termp_pp_pre, NULL }, /* Pp */
169: { termp_d1_pre, termp_d1_post }, /* D1 */
170: { NULL, NULL }, /* Dl */
1.12 kristaps 171: { termp_bd_pre, termp_bd_post }, /* Bd */
1.10 kristaps 172: { NULL, NULL }, /* Ed */
173: { NULL, termp_bl_post }, /* Bl */
174: { NULL, NULL }, /* El */
175: { termp_it_pre, termp_it_post }, /* It */
176: { NULL, NULL }, /* Ad */
177: { NULL, NULL }, /* An */
1.18 kristaps 178: { termp_ar_pre, NULL }, /* Ar */
179: { termp_cd_pre, NULL }, /* Cd */
180: { termp_cm_pre, NULL }, /* Cm */
1.10 kristaps 181: { NULL, NULL }, /* Dv */
182: { NULL, NULL }, /* Er */
183: { NULL, NULL }, /* Ev */
184: { termp_ex_pre, NULL }, /* Ex */
1.18 kristaps 185: { termp_fa_pre, NULL }, /* Fa */
1.10 kristaps 186: { termp_fd_pre, termp_fd_post }, /* Fd */
1.18 kristaps 187: { termp_fl_pre, NULL }, /* Fl */
1.10 kristaps 188: { termp_fn_pre, termp_fn_post }, /* Fn */
189: { termp_ft_pre, termp_ft_post }, /* Ft */
1.18 kristaps 190: { termp_ic_pre, NULL }, /* Ic */
191: { termp_in_pre, NULL }, /* In */
1.10 kristaps 192: { NULL, NULL }, /* Li */
193: { termp_nd_pre, NULL }, /* Nd */
1.18 kristaps 194: { termp_nm_pre, NULL }, /* Nm */
1.10 kristaps 195: { termp_op_pre, termp_op_post }, /* Op */
196: { NULL, NULL }, /* Ot */
1.18 kristaps 197: { termp_pa_pre, NULL }, /* Pa */
1.14 kristaps 198: { termp_rv_pre, NULL }, /* Rv */
199: { termp_st_pre, NULL }, /* St */
1.18 kristaps 200: { termp_va_pre, NULL }, /* Va */
1.10 kristaps 201: { termp_vt_pre, termp_vt_post }, /* Vt */
202: { termp_xr_pre, NULL }, /* Xr */
203: { NULL, NULL }, /* %A */
204: { NULL, NULL }, /* %B */
205: { NULL, NULL }, /* %D */
206: { NULL, NULL }, /* %I */
207: { NULL, NULL }, /* %J */
208: { NULL, NULL }, /* %N */
209: { NULL, NULL }, /* %O */
210: { NULL, NULL }, /* %P */
211: { NULL, NULL }, /* %R */
212: { NULL, NULL }, /* %T */
213: { NULL, NULL }, /* %V */
214: { NULL, NULL }, /* Ac */
1.14 kristaps 215: { termp_aq_pre, termp_aq_post }, /* Ao */
1.10 kristaps 216: { termp_aq_pre, termp_aq_post }, /* Aq */
1.14 kristaps 217: { termp_at_pre, NULL }, /* At */
1.10 kristaps 218: { NULL, NULL }, /* Bc */
1.18 kristaps 219: { termp_bf_pre, NULL }, /* Bf */
1.15 kristaps 220: { termp_bq_pre, termp_bq_post }, /* Bo */
221: { termp_bq_pre, termp_bq_post }, /* Bq */
222: { termp_bsx_pre, NULL }, /* Bsx */
1.10 kristaps 223: { termp_bx_pre, NULL }, /* Bx */
224: { NULL, NULL }, /* Db */
225: { NULL, NULL }, /* Dc */
1.15 kristaps 226: { termp_dq_pre, termp_dq_post }, /* Do */
1.10 kristaps 227: { termp_dq_pre, termp_dq_post }, /* Dq */
228: { NULL, NULL }, /* Ec */
229: { NULL, NULL }, /* Ef */
1.18 kristaps 230: { termp_em_pre, NULL }, /* Em */
1.10 kristaps 231: { NULL, NULL }, /* Eo */
1.16 kristaps 232: { termp_fx_pre, NULL }, /* Fx */
1.18 kristaps 233: { termp_ms_pre, NULL }, /* Ms */
1.10 kristaps 234: { NULL, NULL }, /* No */
235: { termp_ns_pre, NULL }, /* Ns */
236: { termp_nx_pre, NULL }, /* Nx */
237: { termp_ox_pre, NULL }, /* Ox */
238: { NULL, NULL }, /* Pc */
239: { termp_pf_pre, termp_pf_post }, /* Pf */
1.15 kristaps 240: { termp_pq_pre, termp_pq_post }, /* Po */
241: { termp_pq_pre, termp_pq_post }, /* Pq */
1.10 kristaps 242: { NULL, NULL }, /* Qc */
1.16 kristaps 243: { termp_sq_pre, termp_sq_post }, /* Ql */
1.15 kristaps 244: { termp_qq_pre, termp_qq_post }, /* Qo */
1.10 kristaps 245: { termp_qq_pre, termp_qq_post }, /* Qq */
246: { NULL, NULL }, /* Re */
247: { NULL, NULL }, /* Rs */
248: { NULL, NULL }, /* Sc */
1.15 kristaps 249: { termp_sq_pre, termp_sq_post }, /* So */
1.10 kristaps 250: { termp_sq_pre, termp_sq_post }, /* Sq */
251: { NULL, NULL }, /* Sm */
1.18 kristaps 252: { termp_sx_pre, NULL }, /* Sx */
253: { termp_sy_pre, NULL }, /* Sy */
1.10 kristaps 254: { NULL, NULL }, /* Tn */
1.16 kristaps 255: { termp_ux_pre, NULL }, /* Ux */
1.10 kristaps 256: { NULL, NULL }, /* Xc */
257: { NULL, NULL }, /* Xo */
1.16 kristaps 258: { termp_fo_pre, termp_fo_post }, /* Fo */
1.10 kristaps 259: { NULL, NULL }, /* Fc */
1.16 kristaps 260: { termp_op_pre, termp_op_post }, /* Oo */
1.10 kristaps 261: { NULL, NULL }, /* Oc */
262: { NULL, NULL }, /* Bk */
263: { NULL, NULL }, /* Ek */
1.17 kristaps 264: { termp_bt_pre, NULL }, /* Bt */
1.10 kristaps 265: { NULL, NULL }, /* Hf */
266: { NULL, NULL }, /* Fr */
267: { termp_ud_pre, NULL }, /* Ud */
1.2 kristaps 268: };
269:
1.10 kristaps 270: const struct termact *termacts = __termacts;
271:
272:
273: static size_t
1.12 kristaps 274: arg_width(const struct mdoc_arg *arg)
1.10 kristaps 275: {
1.12 kristaps 276:
277: /* TODO */
278: assert(*arg->value);
279: return(strlen(*arg->value));
280: }
281:
282:
283: static size_t
284: arg_offset(const struct mdoc_arg *arg)
285: {
286:
287: /* TODO */
288: assert(*arg->value);
289: if (0 == strcmp(*arg->value, "indent"))
1.10 kristaps 290: return(INDENT);
1.12 kristaps 291: if (0 == strcmp(*arg->value, "indent-two"))
1.10 kristaps 292: return(INDENT * 2);
293:
1.12 kristaps 294: return(strlen(*arg->value));
1.10 kristaps 295: }
296:
1.3 kristaps 297:
1.10 kristaps 298: static int
299: arg_hasattr(int arg, size_t argc, const struct mdoc_arg *argv)
1.2 kristaps 300: {
301:
1.10 kristaps 302: return(-1 != arg_getattr(arg, argc, argv));
303: }
304:
305:
306: static int
307: arg_getattr(int arg, size_t argc, const struct mdoc_arg *argv)
308: {
309: int i;
310:
311: for (i = 0; i < (int)argc; i++)
312: if (argv[i].arg == arg)
313: return(i);
314: return(-1);
315: }
316:
317:
318: /* ARGSUSED */
319: static int
320: termp_dq_pre(DECL_ARGS)
321: {
322:
323: if (MDOC_BODY != node->type)
324: return(1);
325:
326: word(p, "``");
327: p->flags |= TERMP_NOSPACE;
328: return(1);
329: }
330:
331:
332: /* ARGSUSED */
333: static void
334: termp_dq_post(DECL_ARGS)
335: {
336:
337: if (MDOC_BODY != node->type)
338: return;
1.3 kristaps 339:
1.10 kristaps 340: p->flags |= TERMP_NOSPACE;
341: word(p, "''");
342: }
1.2 kristaps 343:
1.3 kristaps 344:
1.10 kristaps 345: /* ARGSUSED */
346: static void
347: termp_it_post(DECL_ARGS)
348: {
349: const struct mdoc_node *n, *it;
350: const struct mdoc_block *bl;
351: int i;
1.12 kristaps 352: size_t width, offset;
1.2 kristaps 353:
1.8 kristaps 354: /*
1.10 kristaps 355: * This (and termp_it_pre()) are the most complicated functions
356: * here. They must account for a considerable number of
357: * switches that completely change the output behaviour, like
358: * -tag versus -column. Yech.
1.8 kristaps 359: */
1.10 kristaps 360:
361: switch (node->type) {
362: case (MDOC_BODY):
363: /* FALLTHROUGH */
364: case (MDOC_HEAD):
365: break;
366: default:
1.8 kristaps 367: return;
368: }
369:
1.10 kristaps 370: it = node->parent;
371: assert(MDOC_BLOCK == it->type);
372: assert(MDOC_It == it->tok);
373:
374: n = it->parent;
375: assert(MDOC_BODY == n->type);
376: assert(MDOC_Bl == n->tok);
377: n = n->parent;
378: bl = &n->data.block;
379:
380: /* If `-tag', adjust our margins accordingly. */
381:
382: if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) {
1.12 kristaps 383: flushln(p);
384:
385: /* FIXME: this should auto-size. */
1.10 kristaps 386: i = arg_getattr(MDOC_Width, bl->argc, bl->argv);
1.12 kristaps 387: width = i >= 0 ? arg_width(&bl->argv[i]) : 10;
388:
389: /* FIXME: nesting! Should happen at block. */
390: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
391: offset = i >= 0 ? arg_width(&bl->argv[i]) : 0;
1.10 kristaps 392:
393: if (MDOC_HEAD == node->type) {
394: p->rmargin = p->maxrmargin;
1.12 kristaps 395: p->offset -= offset;
1.10 kristaps 396: p->flags &= ~TERMP_NOBREAK;
397: } else {
1.12 kristaps 398: p->offset -= width;
1.10 kristaps 399: p->flags &= ~TERMP_NOLPAD;
1.2 kristaps 400: }
1.10 kristaps 401: }
1.2 kristaps 402:
1.10 kristaps 403: if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) {
404: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
1.12 kristaps 405: offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;
1.3 kristaps 406:
1.10 kristaps 407: flushln(p);
1.12 kristaps 408: p->offset -= offset;
1.10 kristaps 409: return;
1.2 kristaps 410: }
1.10 kristaps 411: }
412:
413:
414: /* ARGSUSED */
415: static int
416: termp_it_pre(DECL_ARGS)
417: {
418: const struct mdoc_node *n, *it;
419: const struct mdoc_block *bl;
420: int i;
1.12 kristaps 421: size_t width, offset;
1.2 kristaps 422:
1.3 kristaps 423: /*
1.10 kristaps 424: * Also see termp_it_post() for general comments.
1.3 kristaps 425: */
426:
1.10 kristaps 427: switch (node->type) {
428: case (MDOC_BODY):
429: /* FALLTHROUGH */
430: case (MDOC_HEAD):
431: it = node->parent;
432: break;
433: case (MDOC_BLOCK):
434: it = node;
435: break;
436: default:
437: return(1);
438: }
439:
440: assert(MDOC_BLOCK == it->type);
441: assert(MDOC_It == it->tok);
442:
443: n = it->parent;
444: assert(MDOC_BODY == n->type);
445: assert(MDOC_Bl == n->tok);
446: n = n->parent;
447: bl = &n->data.block;
448:
449: /* If `-compact', don't assert vertical space. */
450:
451: if (MDOC_BLOCK == node->type) {
452: if (arg_hasattr(MDOC_Compact, bl->argc, bl->argv))
453: newln(p);
454: else
455: vspace(p);
456: return(1);
457: }
458:
459: assert(MDOC_HEAD == node->type
460: || MDOC_BODY == node->type);
461:
1.12 kristaps 462: /* FIXME: see termp_it_post(). */
463:
1.10 kristaps 464: /* If `-tag', adjust our margins accordingly. */
465:
466: if (arg_hasattr(MDOC_Tag, bl->argc, bl->argv)) {
1.12 kristaps 467: p->flags |= TERMP_NOSPACE;
468:
1.10 kristaps 469: i = arg_getattr(MDOC_Width, bl->argc, bl->argv);
1.12 kristaps 470: width = i >= 0 ? arg_width(&bl->argv[i]) : 10;
1.10 kristaps 471:
1.12 kristaps 472: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
473: offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;
1.10 kristaps 474:
475: if (MDOC_HEAD == node->type) {
476: p->flags |= TERMP_NOBREAK;
1.12 kristaps 477: p->offset += offset;
1.10 kristaps 478: p->rmargin = p->offset + width;
479: } else {
480: p->flags |= TERMP_NOSPACE;
481: p->flags |= TERMP_NOLPAD;
1.12 kristaps 482: p->offset += width;
1.10 kristaps 483: }
484: return(1);
485: }
486:
487: /* If `-ohang', adjust left-margin. */
488:
489: if (arg_hasattr(MDOC_Ohang, bl->argc, bl->argv)) {
490: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
1.12 kristaps 491: offset = i >= 0 ? arg_offset(&bl->argv[i]) : 0;
1.10 kristaps 492:
493: p->flags |= TERMP_NOSPACE;
1.12 kristaps 494: p->offset += offset;
1.10 kristaps 495: return(1);
496: }
1.3 kristaps 497:
1.10 kristaps 498: return(1);
1.2 kristaps 499: }
500:
501:
1.10 kristaps 502: /* ARGSUSED */
1.18 kristaps 503: static int
504: termp_nm_pre(DECL_ARGS)
1.10 kristaps 505: {
506:
1.18 kristaps 507: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_PROG]);
508: if (NULL == node->child)
509: word(p, meta->name);
510: return(1);
1.10 kristaps 511: }
512:
513:
514: /* ARGSUSED */
1.18 kristaps 515: static int
516: termp_fl_pre(DECL_ARGS)
1.10 kristaps 517: {
518:
1.18 kristaps 519: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_FLAG]);
520: word(p, "\\-");
521: p->flags |= TERMP_NOSPACE;
522: return(1);
1.10 kristaps 523: }
524:
525:
526: /* ARGSUSED */
527: static int
528: termp_ar_pre(DECL_ARGS)
529: {
530:
1.18 kristaps 531: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_CMD_ARG]);
1.10 kristaps 532: if (NULL == node->child)
533: word(p, "...");
534: return(1);
535: }
536:
537:
538: /* ARGSUSED */
539: static int
540: termp_ns_pre(DECL_ARGS)
1.2 kristaps 541: {
542:
543: p->flags |= TERMP_NOSPACE;
1.10 kristaps 544: return(1);
545: }
546:
547:
548: /* ARGSUSED */
549: static int
550: termp_pp_pre(DECL_ARGS)
551: {
552:
553: vspace(p);
554: return(1);
555: }
556:
557:
558: /* ARGSUSED */
559: static int
1.14 kristaps 560: termp_st_pre(DECL_ARGS)
561: {
562: const char *tp;
563:
564: assert(1 == node->data.elem.argc);
565:
566: tp = mdoc_st2a(node->data.elem.argv[0].arg);
567: word(p, tp);
568:
569: return(1);
570: }
571:
572:
573: /* ARGSUSED */
574: static int
575: termp_rv_pre(DECL_ARGS)
576: {
577: int i;
578:
579: i = arg_getattr(MDOC_Std, node->data.elem.argc,
580: node->data.elem.argv);
581: assert(i >= 0);
582:
583: newln(p);
584: word(p, "The");
585:
586: p->flags |= ttypes[TTYPE_FUNC_NAME];
587: word(p, *node->data.elem.argv[i].value);
588: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
589:
590: word(p, "() function returns the value 0 if successful;");
591: word(p, "otherwise the value -1 is returned and the");
592: word(p, "global variable");
593:
594: p->flags |= ttypes[TTYPE_VAR_DECL];
595: word(p, "errno");
596: p->flags &= ~ttypes[TTYPE_VAR_DECL];
597:
598: word(p, "is set to indicate the error.");
599:
600: return(1);
601: }
602:
603:
604: /* ARGSUSED */
605: static int
1.10 kristaps 606: termp_ex_pre(DECL_ARGS)
607: {
608: int i;
609:
610: i = arg_getattr(MDOC_Std, node->data.elem.argc,
611: node->data.elem.argv);
612: assert(i >= 0);
613:
614: word(p, "The");
615: p->flags |= ttypes[TTYPE_PROG];
616: word(p, *node->data.elem.argv[i].value);
617: p->flags &= ~ttypes[TTYPE_PROG];
618: word(p, "utility exits 0 on success, and >0 if an error occurs.");
619:
620: return(1);
621: }
622:
623:
624: /* ARGSUSED */
625: static int
626: termp_nd_pre(DECL_ARGS)
627: {
628:
629: word(p, "\\-");
630: return(1);
631: }
632:
633:
634: /* ARGSUSED */
635: static void
636: termp_bl_post(DECL_ARGS)
637: {
638:
639: if (MDOC_BLOCK == node->type)
640: newln(p);
641: }
642:
643:
644: /* ARGSUSED */
645: static void
646: termp_op_post(DECL_ARGS)
647: {
648:
649: if (MDOC_BODY != node->type)
1.2 kristaps 650: return;
1.10 kristaps 651: p->flags |= TERMP_NOSPACE;
652: word(p, "\\(rB");
653: }
654:
655:
656: /* ARGSUSED */
657: static int
658: termp_xr_pre(DECL_ARGS)
659: {
660: const struct mdoc_node *n;
661:
662: n = node->child;
663: assert(n);
664:
665: assert(MDOC_TEXT == n->type);
666: word(p, n->data.text.string);
667:
668: if (NULL == (n = n->next))
669: return(0);
670:
671: assert(MDOC_TEXT == n->type);
672: p->flags |= TERMP_NOSPACE;
673: word(p, "(");
674: p->flags |= TERMP_NOSPACE;
675: word(p, n->data.text.string);
676: p->flags |= TERMP_NOSPACE;
677: word(p, ")");
678:
679: return(0);
1.2 kristaps 680: }
681:
682:
1.10 kristaps 683: /* ARGSUSED */
684: static int
685: termp_vt_pre(DECL_ARGS)
1.2 kristaps 686: {
687:
1.10 kristaps 688: /* FIXME: this can be "type name". */
1.18 kristaps 689: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]);
1.10 kristaps 690: return(1);
1.2 kristaps 691: }
692:
693:
1.10 kristaps 694: /* ARGSUSED */
1.2 kristaps 695: static void
1.10 kristaps 696: termp_vt_post(DECL_ARGS)
697: {
698:
699: if (node->sec == SEC_SYNOPSIS)
700: vspace(p);
701: }
702:
703:
704: /* ARGSUSED */
705: static int
706: termp_fd_pre(DECL_ARGS)
1.2 kristaps 707: {
708:
1.10 kristaps 709: /*
710: * FIXME: this naming is bad. This value is used, in general,
711: * for the #include header or other preprocessor statement.
712: */
1.18 kristaps 713: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_DECL]);
1.10 kristaps 714: return(1);
1.2 kristaps 715: }
716:
717:
1.10 kristaps 718: /* ARGSUSED */
1.2 kristaps 719: static void
1.10 kristaps 720: termp_fd_post(DECL_ARGS)
1.2 kristaps 721: {
722:
1.10 kristaps 723: if (node->sec == SEC_SYNOPSIS)
724: vspace(p);
725: }
726:
727:
728: /* ARGSUSED */
729: static int
730: termp_sh_pre(DECL_ARGS)
731: {
1.2 kristaps 732:
1.10 kristaps 733: switch (node->type) {
734: case (MDOC_HEAD):
735: vspace(p);
1.18 kristaps 736: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_SECTION]);
1.2 kristaps 737: break;
1.10 kristaps 738: case (MDOC_BODY):
739: p->offset = INDENT;
1.2 kristaps 740: break;
1.10 kristaps 741: default:
742: break;
743: }
744: return(1);
745: }
746:
747:
748: /* ARGSUSED */
1.19 ! kristaps 749: static void
! 750: termp_sh_post(DECL_ARGS)
! 751: {
! 752:
! 753: switch (node->type) {
! 754: case (MDOC_HEAD):
! 755: newln(p);
! 756: break;
! 757: case (MDOC_BODY):
! 758: newln(p);
! 759: p->offset = 0;
! 760: break;
! 761: default:
! 762: break;
! 763: }
! 764: }
! 765:
! 766:
! 767: /* ARGSUSED */
1.10 kristaps 768: static int
769: termp_op_pre(DECL_ARGS)
770: {
771:
772: switch (node->type) {
773: case (MDOC_BODY):
774: word(p, "\\(lB");
775: p->flags |= TERMP_NOSPACE;
1.2 kristaps 776: break;
777: default:
1.10 kristaps 778: break;
1.2 kristaps 779: }
1.10 kristaps 780: return(1);
781: }
782:
783:
784: /* ARGSUSED */
785: static int
1.17 kristaps 786: termp_bt_pre(DECL_ARGS)
787: {
788:
789: word(p, "is currently in beta test.");
790: return(1);
791: }
792:
793:
794: /* ARGSUSED */
795: static int
1.10 kristaps 796: termp_ud_pre(DECL_ARGS)
797: {
798:
799: word(p, "currently under development.");
800: return(1);
801: }
802:
803:
804: /* ARGSUSED */
805: static int
806: termp_d1_pre(DECL_ARGS)
807: {
808:
809: if (MDOC_BODY != node->type)
810: return(1);
811: newln(p);
1.19 ! kristaps 812: p->offset += (pair->offset = INDENT);
1.10 kristaps 813: return(1);
1.2 kristaps 814: }
815:
816:
1.10 kristaps 817: /* ARGSUSED */
1.2 kristaps 818: static void
1.10 kristaps 819: termp_d1_post(DECL_ARGS)
820: {
821:
822: if (MDOC_BODY != node->type)
823: return;
824: newln(p);
1.19 ! kristaps 825: p->offset -= pair->offset;
1.10 kristaps 826: }
827:
828:
829: /* ARGSUSED */
830: static int
831: termp_aq_pre(DECL_ARGS)
1.6 kristaps 832: {
833:
1.10 kristaps 834: if (MDOC_BODY != node->type)
835: return(1);
836: word(p, "<");
837: p->flags |= TERMP_NOSPACE;
838: return(1);
839: }
1.6 kristaps 840:
841:
1.10 kristaps 842: /* ARGSUSED */
843: static void
844: termp_aq_post(DECL_ARGS)
845: {
1.6 kristaps 846:
1.10 kristaps 847: if (MDOC_BODY != node->type)
1.6 kristaps 848: return;
1.10 kristaps 849: p->flags |= TERMP_NOSPACE;
850: word(p, ">");
851: }
1.6 kristaps 852:
1.10 kristaps 853:
854: /* ARGSUSED */
855: static int
856: termp_ft_pre(DECL_ARGS)
857: {
858:
1.18 kristaps 859: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_TYPE]);
1.10 kristaps 860: return(1);
1.6 kristaps 861: }
862:
863:
1.10 kristaps 864: /* ARGSUSED */
1.6 kristaps 865: static void
1.10 kristaps 866: termp_ft_post(DECL_ARGS)
1.2 kristaps 867: {
868:
1.10 kristaps 869: if (node->sec == SEC_SYNOPSIS)
870: newln(p);
871: }
1.2 kristaps 872:
873:
1.10 kristaps 874: /* ARGSUSED */
875: static int
876: termp_fn_pre(DECL_ARGS)
877: {
878: const struct mdoc_node *n;
879:
880: assert(node->child);
881: assert(MDOC_TEXT == node->child->type);
1.2 kristaps 882:
1.10 kristaps 883: /* FIXME: can be "type funcname" "type varname"... */
1.2 kristaps 884:
1.10 kristaps 885: p->flags |= ttypes[TTYPE_FUNC_NAME];
886: word(p, node->child->data.text.string);
887: p->flags &= ~ttypes[TTYPE_FUNC_NAME];
888:
889: word(p, "(");
890:
891: p->flags |= TERMP_NOSPACE;
892: for (n = node->child->next; n; n = n->next) {
893: assert(MDOC_TEXT == n->type);
894: p->flags |= ttypes[TTYPE_FUNC_ARG];
895: word(p, n->data.text.string);
896: p->flags &= ~ttypes[TTYPE_FUNC_ARG];
1.16 kristaps 897: if (n->next)
1.10 kristaps 898: word(p, ",");
1.6 kristaps 899: }
1.2 kristaps 900:
1.10 kristaps 901: word(p, ")");
902:
903: if (SEC_SYNOPSIS == node->sec)
904: word(p, ";");
905:
906: return(0);
1.2 kristaps 907: }
908:
909:
1.10 kristaps 910: /* ARGSUSED */
911: static void
912: termp_fn_post(DECL_ARGS)
1.2 kristaps 913: {
914:
1.10 kristaps 915: if (node->sec == SEC_SYNOPSIS)
916: vspace(p);
917:
918: }
1.2 kristaps 919:
920:
1.10 kristaps 921: /* ARGSUSED */
922: static int
923: termp_sx_pre(DECL_ARGS)
924: {
1.8 kristaps 925:
1.18 kristaps 926: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_LINK]);
1.10 kristaps 927: return(1);
1.2 kristaps 928: }
929:
930:
1.10 kristaps 931: /* ARGSUSED */
932: static int
933: termp_fa_pre(DECL_ARGS)
934: {
1.16 kristaps 935: struct mdoc_node *n;
936:
937: if (node->parent->tok != MDOC_Fo) {
1.18 kristaps 938: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_FUNC_ARG]);
1.16 kristaps 939: return(1);
940: }
941:
942: for (n = node->child; n; n = n->next) {
943: assert(MDOC_TEXT == n->type);
944:
945: p->flags |= ttypes[TTYPE_FUNC_ARG];
946: word(p, n->data.text.string);
947: p->flags &= ~ttypes[TTYPE_FUNC_ARG];
948:
949: if (n->next)
950: word(p, ",");
951: }
952:
953: if (node->next && node->next->tok == MDOC_Fa)
954: word(p, ",");
1.2 kristaps 955:
1.16 kristaps 956: return(0);
1.10 kristaps 957: }
1.2 kristaps 958:
959:
1.10 kristaps 960: /* ARGSUSED */
961: static int
962: termp_va_pre(DECL_ARGS)
963: {
1.2 kristaps 964:
1.18 kristaps 965: TERMPAIR_SETFLAG(pair, ttypes[TTYPE_VAR_DECL]);
1.10 kristaps 966: return(1);
1.2 kristaps 967: }
968:
969:
1.10 kristaps 970: /* ARGSUSED */
971: static int
972: termp_bd_pre(DECL_ARGS)
973: {
974: const struct mdoc_block *bl;
975: const struct mdoc_node *n;
1.12 kristaps 976: int i;
1.1 kristaps 977:
1.10 kristaps 978: if (MDOC_BLOCK == node->type) {
979: vspace(p);
980: return(1);
981: } else if (MDOC_BODY != node->type)
982: return(1);
983:
984: assert(MDOC_BLOCK == node->parent->type);
985:
986: bl = &node->parent->data.block;
1.12 kristaps 987:
988: i = arg_getattr(MDOC_Offset, bl->argc, bl->argv);
989: if (-1 != i) {
990: assert(1 == bl->argv[i].sz);
1.19 ! kristaps 991: pair->offset = arg_offset(&bl->argv[i]);
! 992: p->offset += pair->offset;
1.12 kristaps 993: }
994:
1.10 kristaps 995: if ( ! arg_hasattr(MDOC_Literal, bl->argc, bl->argv))
996: return(1);
997:
998: p->flags |= TERMP_LITERAL;
999:
1000: for (n = node->child; n; n = n->next) {
1001: assert(MDOC_TEXT == n->type); /* FIXME */
1002: if ((*n->data.text.string)) {
1003: word(p, n->data.text.string);
1004: flushln(p);
1005: } else
1006: vspace(p);
1.1 kristaps 1007:
1.10 kristaps 1008: }
1.1 kristaps 1009:
1.10 kristaps 1010: p->flags &= ~TERMP_LITERAL;
1011: return(0);
1012: }
1.1 kristaps 1013:
1014:
1.10 kristaps 1015: /* ARGSUSED */
1.12 kristaps 1016: static void
1017: termp_bd_post(DECL_ARGS)
1018: {
1019:
1.19 ! kristaps 1020: if (MDOC_BODY == node->type)
! 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:
CVSweb