Annotation of mandoc/man_macro.c, Revision 1.149
1.149 ! schwarze 1: /* $Id: man_macro.c,v 1.148 2022/04/27 17:11:24 schwarze Exp $ */
1.1 kristaps 2: /*
1.146 schwarze 3: * Copyright (c) 2012-2015,2017-2020,2022 Ingo Schwarze <schwarze@openbsd.org>
1.65 schwarze 4: * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.79 schwarze 5: * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
1.1 kristaps 6: *
7: * Permission to use, copy, modify, and distribute this software for any
1.14 kristaps 8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
1.1 kristaps 10: *
1.101 schwarze 11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
1.14 kristaps 12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1.101 schwarze 13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
1.14 kristaps 14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1 kristaps 18: */
1.30 kristaps 19: #include "config.h"
1.88 schwarze 20:
21: #include <sys/types.h>
1.30 kristaps 22:
1.1 kristaps 23: #include <assert.h>
24: #include <ctype.h>
1.134 schwarze 25: #include <stdio.h>
1.1 kristaps 26: #include <stdlib.h>
27: #include <string.h>
28:
1.147 schwarze 29: #if DEBUG_MEMORY
30: #include "mandoc_dbg.h"
31: #endif
1.101 schwarze 32: #include "mandoc.h"
33: #include "roff.h"
1.58 kristaps 34: #include "man.h"
1.57 kristaps 35: #include "libmandoc.h"
1.106 schwarze 36: #include "roff_int.h"
1.1 kristaps 37: #include "libman.h"
38:
1.91 schwarze 39: static void blk_close(MACRO_PROT_ARGS);
40: static void blk_exp(MACRO_PROT_ARGS);
41: static void blk_imp(MACRO_PROT_ARGS);
42: static void in_line_eoln(MACRO_PROT_ARGS);
1.105 schwarze 43: static int man_args(struct roff_man *, int,
1.60 kristaps 44: int *, char *, char **);
1.116 schwarze 45: static void rew_scope(struct roff_man *, enum roff_tok);
1.19 kristaps 46:
1.127 schwarze 47: static const struct man_macro man_macros[MAN_MAX - MAN_TH] = {
1.133 schwarze 48: { in_line_eoln, MAN_XSCOPE }, /* TH */
49: { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* SH */
50: { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* SS */
51: { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* TP */
52: { blk_imp, MAN_XSCOPE | MAN_BSCOPED }, /* TQ */
53: { blk_imp, MAN_XSCOPE }, /* LP */
54: { blk_imp, MAN_XSCOPE }, /* PP */
55: { blk_imp, MAN_XSCOPE }, /* P */
56: { blk_imp, MAN_XSCOPE }, /* IP */
57: { blk_imp, MAN_XSCOPE }, /* HP */
58: { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* SM */
59: { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* SB */
1.19 kristaps 60: { in_line_eoln, 0 }, /* BI */
61: { in_line_eoln, 0 }, /* IB */
62: { in_line_eoln, 0 }, /* BR */
63: { in_line_eoln, 0 }, /* RB */
1.133 schwarze 64: { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* R */
65: { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* B */
66: { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* I */
1.19 kristaps 67: { in_line_eoln, 0 }, /* IR */
68: { in_line_eoln, 0 }, /* RI */
1.133 schwarze 69: { blk_close, MAN_XSCOPE }, /* RE */
70: { blk_exp, MAN_XSCOPE }, /* RS */
1.148 schwarze 71: { in_line_eoln, MAN_NSCOPED }, /* DT */
72: { in_line_eoln, MAN_NSCOPED }, /* UC */
1.100 schwarze 73: { in_line_eoln, MAN_NSCOPED }, /* PD */
1.148 schwarze 74: { in_line_eoln, MAN_NSCOPED }, /* AT */
1.122 schwarze 75: { in_line_eoln, MAN_NSCOPED }, /* in */
1.133 schwarze 76: { blk_imp, MAN_XSCOPE }, /* SY */
77: { blk_close, MAN_XSCOPE }, /* YS */
1.71 kristaps 78: { in_line_eoln, 0 }, /* OP */
1.133 schwarze 79: { in_line_eoln, MAN_XSCOPE }, /* EX */
80: { in_line_eoln, MAN_XSCOPE }, /* EE */
81: { blk_exp, MAN_XSCOPE }, /* UR */
82: { blk_close, MAN_XSCOPE }, /* UE */
83: { blk_exp, MAN_XSCOPE }, /* MT */
84: { blk_close, MAN_XSCOPE }, /* ME */
1.149 ! schwarze 85: { in_line_eoln, 0 }, /* MR */
1.19 kristaps 86: };
1.1 kristaps 87:
88:
1.127 schwarze 89: const struct man_macro *
90: man_macro(enum roff_tok tok)
91: {
92: assert(tok >= MAN_TH && tok <= MAN_MAX);
93: return man_macros + (tok - MAN_TH);
94: }
95:
1.91 schwarze 96: void
1.105 schwarze 97: man_unscope(struct roff_man *man, const struct roff_node *to)
1.1 kristaps 98: {
1.102 schwarze 99: struct roff_node *n;
1.1 kristaps 100:
1.83 schwarze 101: to = to->parent;
102: n = man->last;
103: while (n != to) {
1.87 schwarze 104:
105: /* Reached the end of the document? */
106:
1.115 schwarze 107: if (to == NULL && ! (n->flags & NODE_VALID)) {
1.87 schwarze 108: if (man->flags & (MAN_BLINE | MAN_ELINE) &&
1.133 schwarze 109: man_macro(n->tok)->flags &
110: (MAN_BSCOPED | MAN_NSCOPED)) {
1.135 schwarze 111: mandoc_msg(MANDOCERR_BLK_LINE,
112: n->line, n->pos,
1.116 schwarze 113: "EOF breaks %s", roff_name[n->tok]);
1.145 schwarze 114: if (man->flags & MAN_ELINE) {
1.146 schwarze 115: if (n->parent->type == ROFFT_ROOT ||
116: (man_macro(n->parent->tok)->flags &
1.145 schwarze 117: MAN_ESCOPED) == 0)
118: man->flags &= ~MAN_ELINE;
119: } else {
1.101 schwarze 120: assert(n->type == ROFFT_HEAD);
1.87 schwarze 121: n = n->parent;
122: man->flags &= ~MAN_BLINE;
123: }
124: man->last = n;
125: n = n->parent;
1.106 schwarze 126: roff_node_delete(man, man->last);
1.87 schwarze 127: continue;
128: }
1.101 schwarze 129: if (n->type == ROFFT_BLOCK &&
1.127 schwarze 130: man_macro(n->tok)->fp == blk_exp)
1.87 schwarze 131: mandoc_msg(MANDOCERR_BLK_NOEND,
1.135 schwarze 132: n->line, n->pos, "%s",
1.116 schwarze 133: roff_name[n->tok]);
1.87 schwarze 134: }
135:
1.55 kristaps 136: /*
1.83 schwarze 137: * We might delete the man->last node
138: * in the post-validation phase.
139: * Save a pointer to the parent such that
140: * we know where to continue the iteration.
1.55 kristaps 141: */
1.89 schwarze 142:
1.83 schwarze 143: man->last = n;
144: n = n->parent;
1.115 schwarze 145: man->last->flags |= NODE_VALID;
1.19 kristaps 146: }
1.89 schwarze 147:
148: /*
149: * If we ended up at the parent of the node we were
150: * supposed to rewind to, that means the target node
151: * got deleted, so add the next node we parse as a child
152: * of the parent instead of as a sibling of the target.
153: */
154:
155: man->next = (man->last == to) ?
1.105 schwarze 156: ROFF_NEXT_CHILD : ROFF_NEXT_SIBLING;
1.19 kristaps 157: }
1.1 kristaps 158:
1.19 kristaps 159: /*
160: * Rewinding entails ascending the parse tree until a coherent point,
161: * for example, the `SH' macro will close out any intervening `SS'
162: * scopes. When a scope is closed, it must be validated and actioned.
163: */
1.91 schwarze 164: static void
1.116 schwarze 165: rew_scope(struct roff_man *man, enum roff_tok tok)
1.19 kristaps 166: {
1.102 schwarze 167: struct roff_node *n;
1.7 kristaps 168:
1.104 schwarze 169: /* Preserve empty paragraphs before RS. */
170:
171: n = man->last;
1.114 schwarze 172: if (tok == MAN_RS && n->child == NULL &&
1.104 schwarze 173: (n->tok == MAN_P || n->tok == MAN_PP || n->tok == MAN_LP))
174: return;
175:
176: for (;;) {
177: if (n->type == ROFFT_ROOT)
178: return;
1.115 schwarze 179: if (n->flags & NODE_VALID) {
1.104 schwarze 180: n = n->parent;
181: continue;
182: }
183: if (n->type != ROFFT_BLOCK) {
184: if (n->parent->type == ROFFT_ROOT) {
185: man_unscope(man, n);
186: return;
187: } else {
188: n = n->parent;
189: continue;
190: }
191: }
192: if (tok != MAN_SH && (n->tok == MAN_SH ||
193: (tok != MAN_SS && (n->tok == MAN_SS ||
1.127 schwarze 194: man_macro(n->tok)->fp == blk_exp))))
1.91 schwarze 195: return;
1.104 schwarze 196: man_unscope(man, n);
197: n = man->last;
1.6 kristaps 198: }
1.19 kristaps 199: }
200:
1.6 kristaps 201:
1.36 kristaps 202: /*
203: * Close out a generic explicit macro.
204: */
1.91 schwarze 205: void
1.21 kristaps 206: blk_close(MACRO_PROT_ARGS)
207: {
1.124 schwarze 208: enum roff_tok ctok, ntok;
1.102 schwarze 209: const struct roff_node *nn;
1.137 schwarze 210: char *p, *ep;
211: int cline, cpos, la, nrew, target;
1.21 kristaps 212:
1.93 schwarze 213: nrew = 1;
1.21 kristaps 214: switch (tok) {
1.82 schwarze 215: case MAN_RE:
1.21 kristaps 216: ntok = MAN_RS;
1.137 schwarze 217: la = *pos;
1.93 schwarze 218: if ( ! man_args(man, line, pos, buf, &p))
219: break;
220: for (nn = man->last->parent; nn; nn = nn->parent)
1.101 schwarze 221: if (nn->tok == ntok && nn->type == ROFFT_BLOCK)
1.93 schwarze 222: nrew++;
1.137 schwarze 223: target = strtol(p, &ep, 10);
224: if (*ep != '\0')
1.135 schwarze 225: mandoc_msg(MANDOCERR_ARG_EXCESS, line,
1.137 schwarze 226: la + (buf[la] == '"') + (int)(ep - p),
227: "RE ... %s", ep);
228: free(p);
1.93 schwarze 229: if (target == 0)
230: target = 1;
231: nrew -= target;
232: if (nrew < 1) {
1.135 schwarze 233: mandoc_msg(MANDOCERR_RE_NOTOPEN,
1.93 schwarze 234: line, ppos, "RE %d", target);
235: return;
236: }
1.128 schwarze 237: break;
238: case MAN_YS:
239: ntok = MAN_SY;
1.76 schwarze 240: break;
1.82 schwarze 241: case MAN_UE:
1.76 schwarze 242: ntok = MAN_UR;
1.123 schwarze 243: break;
244: case MAN_ME:
245: ntok = MAN_MT;
1.21 kristaps 246: break;
247: default:
248: abort();
249: }
250:
1.75 schwarze 251: for (nn = man->last->parent; nn; nn = nn->parent)
1.101 schwarze 252: if (nn->tok == ntok && nn->type == ROFFT_BLOCK && ! --nrew)
1.21 kristaps 253: break;
254:
1.91 schwarze 255: if (nn == NULL) {
1.135 schwarze 256: mandoc_msg(MANDOCERR_BLK_NOTOPEN,
257: line, ppos, "%s", roff_name[tok]);
1.104 schwarze 258: rew_scope(man, MAN_PP);
1.131 schwarze 259: if (tok == MAN_RE) {
260: roff_elem_alloc(man, line, ppos, ROFF_br);
261: man->last->flags |= NODE_LINE |
262: NODE_VALID | NODE_ENDED;
263: man->next = ROFF_NEXT_SIBLING;
264: }
1.124 schwarze 265: return;
266: }
267:
268: cline = man->last->line;
269: cpos = man->last->pos;
270: ctok = man->last->tok;
271: man_unscope(man, nn);
272:
273: if (tok == MAN_RE && nn->head->aux > 0)
274: roff_setreg(man->roff, "an-margin", nn->head->aux, '-');
275:
276: /* Trailing text. */
277:
278: if (buf[*pos] != '\0') {
279: roff_word_alloc(man, line, ppos, buf + *pos);
280: man->last->flags |= NODE_DELIMC;
1.130 schwarze 281: if (mandoc_eos(man->last->string, strlen(man->last->string)))
282: man->last->flags |= NODE_EOS;
1.124 schwarze 283: }
284:
285: /* Move a trailing paragraph behind the block. */
286:
287: if (ctok == MAN_LP || ctok == MAN_PP || ctok == MAN_P) {
288: *pos = strlen(buf);
1.125 schwarze 289: blk_imp(man, ctok, cline, cpos, pos, buf);
1.129 schwarze 290: }
291:
292: /* Synopsis blocks need an explicit end marker for spacing. */
293:
294: if (tok == MAN_YS && man->last == nn) {
295: roff_elem_alloc(man, line, ppos, tok);
296: man_unscope(man, man->last);
1.95 schwarze 297: }
1.21 kristaps 298: }
299:
1.91 schwarze 300: void
1.35 kristaps 301: blk_exp(MACRO_PROT_ARGS)
302: {
1.102 schwarze 303: struct roff_node *head;
1.98 schwarze 304: char *p;
1.59 kristaps 305: int la;
1.35 kristaps 306:
1.144 schwarze 307: if (tok == MAN_RS) {
1.132 schwarze 308: rew_scope(man, tok);
1.144 schwarze 309: man->flags |= ROFF_NONOFILL;
310: }
1.108 schwarze 311: roff_block_alloc(man, line, ppos, tok);
1.106 schwarze 312: head = roff_head_alloc(man, line, ppos, tok);
1.35 kristaps 313:
1.98 schwarze 314: la = *pos;
1.121 schwarze 315: if (man_args(man, line, pos, buf, &p)) {
1.107 schwarze 316: roff_word_alloc(man, line, la, p);
1.121 schwarze 317: if (tok == MAN_RS) {
318: if (roff_getreg(man->roff, "an-margin") == 0)
319: roff_setreg(man->roff, "an-margin",
320: 7 * 24, '=');
321: if ((head->aux = strtod(p, NULL) * 24.0) > 0)
322: roff_setreg(man->roff, "an-margin",
323: head->aux, '+');
324: }
1.137 schwarze 325: free(p);
1.121 schwarze 326: }
1.35 kristaps 327:
1.98 schwarze 328: if (buf[*pos] != '\0')
1.135 schwarze 329: mandoc_msg(MANDOCERR_ARG_EXCESS, line, *pos,
330: "%s ... %s", roff_name[tok], buf + *pos);
1.73 schwarze 331:
1.98 schwarze 332: man_unscope(man, head);
1.106 schwarze 333: roff_body_alloc(man, line, ppos, tok);
1.144 schwarze 334: man->flags &= ~ROFF_NONOFILL;
1.35 kristaps 335: }
336:
1.19 kristaps 337: /*
1.101 schwarze 338: * Parse an implicit-block macro. These contain a ROFFT_HEAD and a
339: * ROFFT_BODY contained within a ROFFT_BLOCK. Rules for closing out other
1.19 kristaps 340: * scopes, such as `SH' closing out an `SS', are defined in the rew
341: * routines.
342: */
1.91 schwarze 343: void
1.19 kristaps 344: blk_imp(MACRO_PROT_ARGS)
345: {
1.59 kristaps 346: int la;
1.19 kristaps 347: char *p;
1.102 schwarze 348: struct roff_node *n;
1.19 kristaps 349:
1.104 schwarze 350: rew_scope(man, tok);
1.143 schwarze 351: man->flags |= ROFF_NONOFILL;
1.140 schwarze 352: if (tok == MAN_SH || tok == MAN_SS)
353: man->flags &= ~ROFF_NOFILL;
354: roff_block_alloc(man, line, ppos, tok);
1.106 schwarze 355: n = roff_head_alloc(man, line, ppos, tok);
1.25 kristaps 356:
1.19 kristaps 357: /* Add line arguments. */
1.3 kristaps 358:
1.19 kristaps 359: for (;;) {
360: la = *pos;
1.75 schwarze 361: if ( ! man_args(man, line, pos, buf, &p))
1.19 kristaps 362: break;
1.107 schwarze 363: roff_word_alloc(man, line, la, p);
1.137 schwarze 364: free(p);
1.6 kristaps 365: }
366:
1.99 schwarze 367: /*
368: * For macros having optional next-line scope,
369: * keep the head open if there were no arguments.
1.133 schwarze 370: * For `TP' and `TQ', always keep the head open.
1.99 schwarze 371: */
1.19 kristaps 372:
1.133 schwarze 373: if (man_macro(tok)->flags & MAN_BSCOPED &&
1.126 schwarze 374: (tok == MAN_TP || tok == MAN_TQ || n == man->last)) {
1.99 schwarze 375: man->flags |= MAN_BLINE;
376: return;
1.27 kristaps 377: }
1.99 schwarze 378:
379: /* Close out the head and open the body. */
380:
1.103 schwarze 381: man_unscope(man, n);
1.106 schwarze 382: roff_body_alloc(man, line, ppos, tok);
1.143 schwarze 383: man->flags &= ~ROFF_NONOFILL;
1.4 kristaps 384: }
385:
1.91 schwarze 386: void
1.19 kristaps 387: in_line_eoln(MACRO_PROT_ARGS)
1.3 kristaps 388: {
1.59 kristaps 389: int la;
1.19 kristaps 390: char *p;
1.102 schwarze 391: struct roff_node *n;
1.3 kristaps 392:
1.108 schwarze 393: roff_elem_alloc(man, line, ppos, tok);
1.75 schwarze 394: n = man->last;
1.141 schwarze 395:
396: if (tok == MAN_EX)
397: man->flags |= ROFF_NOFILL;
398: else if (tok == MAN_EE)
399: man->flags &= ~ROFF_NOFILL;
1.147 schwarze 400:
401: #if DEBUG_MEMORY
402: if (tok == MAN_TH)
403: mandoc_dbg_name(buf);
404: #endif
1.3 kristaps 405:
1.19 kristaps 406: for (;;) {
1.120 schwarze 407: if (buf[*pos] != '\0' && man->last != n && tok == MAN_PD) {
1.135 schwarze 408: mandoc_msg(MANDOCERR_ARG_EXCESS, line, *pos,
409: "%s ... %s", roff_name[tok], buf + *pos);
1.96 schwarze 410: break;
411: }
1.19 kristaps 412: la = *pos;
1.75 schwarze 413: if ( ! man_args(man, line, pos, buf, &p))
1.19 kristaps 414: break;
1.127 schwarze 415: if (man_macro(tok)->flags & MAN_JOIN &&
1.101 schwarze 416: man->last->type == ROFFT_TEXT)
1.107 schwarze 417: roff_word_append(man, p);
1.91 schwarze 418: else
1.107 schwarze 419: roff_word_alloc(man, line, la, p);
1.137 schwarze 420: free(p);
1.19 kristaps 421: }
1.78 schwarze 422:
423: /*
1.115 schwarze 424: * Append NODE_EOS in case the last snipped argument
1.78 schwarze 425: * ends with a dot, e.g. `.IR syslog (3).'
426: */
427:
428: if (n != man->last &&
1.80 schwarze 429: mandoc_eos(man->last->string, strlen(man->last->string)))
1.115 schwarze 430: man->last->flags |= NODE_EOS;
1.3 kristaps 431:
1.31 kristaps 432: /*
1.133 schwarze 433: * If no arguments are specified and this is MAN_ESCOPED (i.e.,
1.31 kristaps 434: * next-line scoped), then set our mode to indicate that we're
435: * waiting for terms to load into our context.
436: */
437:
1.133 schwarze 438: if (n == man->last && man_macro(tok)->flags & MAN_ESCOPED) {
1.75 schwarze 439: man->flags |= MAN_ELINE;
1.91 schwarze 440: return;
1.31 kristaps 441: }
1.64 kristaps 442:
1.101 schwarze 443: assert(man->last->type != ROFFT_ROOT);
1.105 schwarze 444: man->next = ROFF_NEXT_SIBLING;
1.82 schwarze 445:
1.113 schwarze 446: /* Rewind our element scope. */
1.3 kristaps 447:
1.75 schwarze 448: for ( ; man->last; man->last = man->last->parent) {
1.142 schwarze 449: man->last->flags |= NODE_VALID;
1.75 schwarze 450: if (man->last == n)
1.19 kristaps 451: break;
452: }
1.133 schwarze 453:
454: /* Rewind next-line scoped ancestors, if any. */
455:
456: if (man_macro(tok)->flags & MAN_ESCOPED)
457: man_descope(man, line, ppos, NULL);
1.19 kristaps 458: }
1.3 kristaps 459:
1.91 schwarze 460: void
1.109 schwarze 461: man_endparse(struct roff_man *man)
1.19 kristaps 462: {
1.138 schwarze 463: man_unscope(man, man->meta.first);
1.19 kristaps 464: }
1.3 kristaps 465:
1.60 kristaps 466: static int
1.105 schwarze 467: man_args(struct roff_man *man, int line, int *pos, char *buf, char **v)
1.60 kristaps 468: {
469: char *start;
470:
471: assert(*pos);
472: *v = start = buf + *pos;
473: assert(' ' != *start);
474:
475: if ('\0' == *start)
1.112 schwarze 476: return 0;
1.60 kristaps 477:
1.137 schwarze 478: *v = roff_getarg(man->roff, v, line, pos);
1.112 schwarze 479: return 1;
1.60 kristaps 480: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to man_macro.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / mandoc