Annotation of src/usr.bin/mandoc/mdoc.c, Revision 1.83
1.83 ! schwarze 1: /* $Id: mdoc.c,v 1.82 2011/04/21 22:59:54 schwarze Exp $ */
1.1 kristaps 2: /*
1.77 schwarze 3: * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
1.61 schwarze 4: * Copyright (c) 2010 Ingo Schwarze <schwarze@openbsd.org>
1.1 kristaps 5: *
6: * Permission to use, copy, modify, and distribute this software for any
1.3 schwarze 7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
1.1 kristaps 9: *
1.3 schwarze 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1.1 kristaps 17: */
1.28 schwarze 18: #include <sys/types.h>
19:
1.1 kristaps 20: #include <assert.h>
21: #include <stdarg.h>
22: #include <stdio.h>
23: #include <stdlib.h>
24: #include <string.h>
1.39 schwarze 25: #include <time.h>
1.1 kristaps 26:
1.83 ! schwarze 27: #include "mdoc.h"
1.54 schwarze 28: #include "mandoc.h"
1.1 kristaps 29: #include "libmdoc.h"
1.32 schwarze 30: #include "libmandoc.h"
1.1 kristaps 31:
32: const char *const __mdoc_macronames[MDOC_MAX] = {
1.7 schwarze 33: "Ap", "Dd", "Dt", "Os",
1.1 kristaps 34: "Sh", "Ss", "Pp", "D1",
35: "Dl", "Bd", "Ed", "Bl",
36: "El", "It", "Ad", "An",
37: "Ar", "Cd", "Cm", "Dv",
38: "Er", "Ev", "Ex", "Fa",
39: "Fd", "Fl", "Fn", "Ft",
40: "Ic", "In", "Li", "Nd",
41: "Nm", "Op", "Ot", "Pa",
42: "Rv", "St", "Va", "Vt",
43: /* LINTED */
1.33 schwarze 44: "Xr", "%A", "%B", "%D",
1.1 kristaps 45: /* LINTED */
1.33 schwarze 46: "%I", "%J", "%N", "%O",
1.1 kristaps 47: /* LINTED */
1.33 schwarze 48: "%P", "%R", "%T", "%V",
1.1 kristaps 49: "Ac", "Ao", "Aq", "At",
50: "Bc", "Bf", "Bo", "Bq",
51: "Bsx", "Bx", "Db", "Dc",
52: "Do", "Dq", "Ec", "Ef",
53: "Em", "Eo", "Fx", "Ms",
54: "No", "Ns", "Nx", "Ox",
55: "Pc", "Pf", "Po", "Pq",
56: "Qc", "Ql", "Qo", "Qq",
57: "Re", "Rs", "Sc", "So",
58: "Sq", "Sm", "Sx", "Sy",
59: "Tn", "Ux", "Xc", "Xo",
60: "Fo", "Fc", "Oo", "Oc",
61: "Bk", "Ek", "Bt", "Hf",
1.7 schwarze 62: "Fr", "Ud", "Lb", "Lp",
63: "Lk", "Mt", "Brq", "Bro",
1.1 kristaps 64: /* LINTED */
1.33 schwarze 65: "Brc", "%C", "Es", "En",
1.1 kristaps 66: /* LINTED */
1.33 schwarze 67: "Dx", "%Q", "br", "sp",
1.31 schwarze 68: /* LINTED */
1.77 schwarze 69: "%U", "Ta"
1.1 kristaps 70: };
71:
72: const char *const __mdoc_argnames[MDOC_ARG_MAX] = {
73: "split", "nosplit", "ragged",
74: "unfilled", "literal", "file",
75: "offset", "bullet", "dash",
76: "hyphen", "item", "enum",
77: "tag", "diag", "hang",
78: "ohang", "inset", "column",
79: "width", "compact", "std",
80: "filled", "words", "emphasis",
1.30 schwarze 81: "symbolic", "nested", "centered"
1.1 kristaps 82: };
83:
84: const char * const *mdoc_macronames = __mdoc_macronames;
85: const char * const *mdoc_argnames = __mdoc_argnames;
86:
1.40 schwarze 87: static void mdoc_node_free(struct mdoc_node *);
88: static void mdoc_node_unlink(struct mdoc *,
89: struct mdoc_node *);
1.1 kristaps 90: static void mdoc_free1(struct mdoc *);
1.32 schwarze 91: static void mdoc_alloc1(struct mdoc *);
1.1 kristaps 92: static struct mdoc_node *node_alloc(struct mdoc *, int, int,
1.37 schwarze 93: enum mdoct, enum mdoc_type);
1.1 kristaps 94: static int node_append(struct mdoc *,
95: struct mdoc_node *);
1.53 schwarze 96: static int mdoc_ptext(struct mdoc *, int, char *, int);
97: static int mdoc_pmacro(struct mdoc *, int, char *, int);
1.1 kristaps 98:
99: const struct mdoc_node *
100: mdoc_node(const struct mdoc *m)
101: {
102:
1.78 schwarze 103: assert( ! (MDOC_HALT & m->flags));
104: return(m->first);
1.1 kristaps 105: }
106:
107:
108: const struct mdoc_meta *
109: mdoc_meta(const struct mdoc *m)
110: {
111:
1.78 schwarze 112: assert( ! (MDOC_HALT & m->flags));
113: return(&m->meta);
1.1 kristaps 114: }
115:
116:
1.8 schwarze 117: /*
118: * Frees volatile resources (parse tree, meta-data, fields).
119: */
1.1 kristaps 120: static void
121: mdoc_free1(struct mdoc *mdoc)
122: {
123:
124: if (mdoc->first)
1.40 schwarze 125: mdoc_node_delete(mdoc, mdoc->first);
1.1 kristaps 126: if (mdoc->meta.title)
127: free(mdoc->meta.title);
128: if (mdoc->meta.os)
129: free(mdoc->meta.os);
130: if (mdoc->meta.name)
131: free(mdoc->meta.name);
132: if (mdoc->meta.arch)
133: free(mdoc->meta.arch);
134: if (mdoc->meta.vol)
135: free(mdoc->meta.vol);
1.50 schwarze 136: if (mdoc->meta.msec)
137: free(mdoc->meta.msec);
1.82 schwarze 138: if (mdoc->meta.date)
139: free(mdoc->meta.date);
1.1 kristaps 140: }
141:
142:
1.8 schwarze 143: /*
144: * Allocate all volatile resources (parse tree, meta-data, fields).
145: */
1.32 schwarze 146: static void
1.1 kristaps 147: mdoc_alloc1(struct mdoc *mdoc)
148: {
149:
1.32 schwarze 150: memset(&mdoc->meta, 0, sizeof(struct mdoc_meta));
1.1 kristaps 151: mdoc->flags = 0;
1.9 schwarze 152: mdoc->lastnamed = mdoc->lastsec = SEC_NONE;
1.32 schwarze 153: mdoc->last = mandoc_calloc(1, sizeof(struct mdoc_node));
1.1 kristaps 154: mdoc->first = mdoc->last;
155: mdoc->last->type = MDOC_ROOT;
156: mdoc->next = MDOC_NEXT_CHILD;
157: }
158:
159:
160: /*
1.8 schwarze 161: * Free up volatile resources (see mdoc_free1()) then re-initialises the
162: * data with mdoc_alloc1(). After invocation, parse data has been reset
163: * and the parser is ready for re-invocation on a new tree; however,
164: * cross-parse non-volatile data is kept intact.
1.1 kristaps 165: */
1.32 schwarze 166: void
1.1 kristaps 167: mdoc_reset(struct mdoc *mdoc)
168: {
169:
170: mdoc_free1(mdoc);
1.32 schwarze 171: mdoc_alloc1(mdoc);
1.1 kristaps 172: }
173:
174:
175: /*
1.8 schwarze 176: * Completely free up all volatile and non-volatile parse resources.
177: * After invocation, the pointer is no longer usable.
1.1 kristaps 178: */
179: void
180: mdoc_free(struct mdoc *mdoc)
181: {
182:
183: mdoc_free1(mdoc);
184: free(mdoc);
185: }
186:
187:
1.8 schwarze 188: /*
189: * Allocate volatile and non-volatile parse resources.
190: */
1.1 kristaps 191: struct mdoc *
1.83 ! schwarze 192: mdoc_alloc(struct regset *regs, struct mparse *parse)
1.1 kristaps 193: {
194: struct mdoc *p;
195:
1.32 schwarze 196: p = mandoc_calloc(1, sizeof(struct mdoc));
197:
1.83 ! schwarze 198: p->parse = parse;
1.58 schwarze 199: p->regs = regs;
1.1 kristaps 200:
1.32 schwarze 201: mdoc_hash_init();
202: mdoc_alloc1(p);
203: return(p);
1.1 kristaps 204: }
205:
206:
207: /*
208: * Climb back up the parse tree, validating open scopes. Mostly calls
1.8 schwarze 209: * through to macro_end() in macro.c.
1.1 kristaps 210: */
211: int
212: mdoc_endparse(struct mdoc *m)
213: {
214:
1.78 schwarze 215: assert( ! (MDOC_HALT & m->flags));
216: if (mdoc_macroend(m))
1.1 kristaps 217: return(1);
218: m->flags |= MDOC_HALT;
219: return(0);
1.81 schwarze 220: }
221:
222: int
223: mdoc_addeqn(struct mdoc *m, const struct eqn *ep)
224: {
225: struct mdoc_node *n;
226:
227: assert( ! (MDOC_HALT & m->flags));
228:
229: /* No text before an initial macro. */
230:
231: if (SEC_NONE == m->lastnamed) {
232: mdoc_pmsg(m, ep->line, ep->pos, MANDOCERR_NOTEXT);
233: return(1);
234: }
235:
236: n = node_alloc(m, ep->line, ep->pos, MDOC_MAX, MDOC_EQN);
237: n->eqn = ep;
238:
239: if ( ! node_append(m, n))
240: return(0);
241:
242: m->next = MDOC_NEXT_SIBLING;
243: return(1);
1.1 kristaps 244: }
245:
1.77 schwarze 246: int
247: mdoc_addspan(struct mdoc *m, const struct tbl_span *sp)
248: {
1.79 schwarze 249: struct mdoc_node *n;
1.77 schwarze 250:
1.78 schwarze 251: assert( ! (MDOC_HALT & m->flags));
1.77 schwarze 252:
253: /* No text before an initial macro. */
254:
255: if (SEC_NONE == m->lastnamed) {
1.79 schwarze 256: mdoc_pmsg(m, sp->line, 0, MANDOCERR_NOTEXT);
1.77 schwarze 257: return(1);
258: }
259:
1.79 schwarze 260: n = node_alloc(m, sp->line, 0, MDOC_MAX, MDOC_TBL);
261: n->span = sp;
262:
263: if ( ! node_append(m, n))
264: return(0);
265:
266: m->next = MDOC_NEXT_SIBLING;
267: return(1);
1.77 schwarze 268: }
269:
1.1 kristaps 270:
271: /*
272: * Main parse routine. Parses a single line -- really just hands off to
1.45 schwarze 273: * the macro (mdoc_pmacro()) or text parser (mdoc_ptext()).
1.1 kristaps 274: */
275: int
1.53 schwarze 276: mdoc_parseln(struct mdoc *m, int ln, char *buf, int offs)
1.1 kristaps 277: {
278:
1.78 schwarze 279: assert( ! (MDOC_HALT & m->flags));
1.1 kristaps 280:
1.47 schwarze 281: m->flags |= MDOC_NEWLINE;
1.60 schwarze 282:
283: /*
284: * Let the roff nS register switch SYNOPSIS mode early,
285: * such that the parser knows at all times
286: * whether this mode is on or off.
287: * Note that this mode is also switched by the Sh macro.
288: */
289: if (m->regs->regs[(int)REG_nS].set) {
290: if (m->regs->regs[(int)REG_nS].v.u)
291: m->flags |= MDOC_SYNOPSIS;
292: else
293: m->flags &= ~MDOC_SYNOPSIS;
294: }
295:
1.83 ! schwarze 296: return(mandoc_getcontrol(buf, &offs) ?
1.53 schwarze 297: mdoc_pmacro(m, ln, buf, offs) :
298: mdoc_ptext(m, ln, buf, offs));
1.1 kristaps 299: }
300:
1.5 schwarze 301: int
1.58 schwarze 302: mdoc_macro(MACRO_PROT_ARGS)
1.1 kristaps 303: {
1.46 schwarze 304: assert(tok < MDOC_MAX);
305:
306: /* If we're in the body, deny prologue calls. */
1.37 schwarze 307:
1.1 kristaps 308: if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&
1.76 schwarze 309: MDOC_PBODY & m->flags) {
310: mdoc_pmsg(m, line, ppos, MANDOCERR_BADBODY);
311: return(1);
312: }
1.46 schwarze 313:
314: /* If we're in the prologue, deny "body" macros. */
315:
1.1 kristaps 316: if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) &&
1.39 schwarze 317: ! (MDOC_PBODY & m->flags)) {
1.76 schwarze 318: mdoc_pmsg(m, line, ppos, MANDOCERR_BADPROLOG);
1.71 schwarze 319: if (NULL == m->meta.msec)
320: m->meta.msec = mandoc_strdup("1");
1.39 schwarze 321: if (NULL == m->meta.title)
1.56 schwarze 322: m->meta.title = mandoc_strdup("UNKNOWN");
1.39 schwarze 323: if (NULL == m->meta.vol)
1.56 schwarze 324: m->meta.vol = mandoc_strdup("LOCAL");
1.39 schwarze 325: if (NULL == m->meta.os)
1.56 schwarze 326: m->meta.os = mandoc_strdup("LOCAL");
1.80 schwarze 327: if (NULL == m->meta.date)
1.83 ! schwarze 328: m->meta.date = mandoc_normdate
! 329: (m->parse, NULL, line, ppos);
1.39 schwarze 330: m->flags |= MDOC_PBODY;
331: }
1.1 kristaps 332:
1.58 schwarze 333: return((*mdoc_macros[tok].fp)(m, tok, line, ppos, pos, buf));
1.1 kristaps 334: }
335:
336:
337: static int
338: node_append(struct mdoc *mdoc, struct mdoc_node *p)
339: {
340:
341: assert(mdoc->last);
342: assert(mdoc->first);
343: assert(MDOC_ROOT != p->type);
344:
345: switch (mdoc->next) {
346: case (MDOC_NEXT_SIBLING):
347: mdoc->last->next = p;
348: p->prev = mdoc->last;
349: p->parent = mdoc->last->parent;
350: break;
351: case (MDOC_NEXT_CHILD):
352: mdoc->last->child = p;
353: p->parent = mdoc->last;
354: break;
355: default:
356: abort();
357: /* NOTREACHED */
358: }
359:
1.10 schwarze 360: p->parent->nchild++;
361:
1.75 schwarze 362: /*
363: * Copy over the normalised-data pointer of our parent. Not
364: * everybody has one, but copying a null pointer is fine.
365: */
366:
367: switch (p->type) {
368: case (MDOC_BODY):
369: /* FALLTHROUGH */
370: case (MDOC_TAIL):
371: /* FALLTHROUGH */
372: case (MDOC_HEAD):
373: p->norm = p->parent->norm;
374: break;
375: default:
376: break;
377: }
378:
1.1 kristaps 379: if ( ! mdoc_valid_pre(mdoc, p))
380: return(0);
381:
382: switch (p->type) {
383: case (MDOC_HEAD):
384: assert(MDOC_BLOCK == p->parent->type);
385: p->parent->head = p;
386: break;
387: case (MDOC_TAIL):
388: assert(MDOC_BLOCK == p->parent->type);
389: p->parent->tail = p;
390: break;
391: case (MDOC_BODY):
1.59 schwarze 392: if (p->end)
393: break;
1.1 kristaps 394: assert(MDOC_BLOCK == p->parent->type);
395: p->parent->body = p;
396: break;
397: default:
398: break;
399: }
400:
401: mdoc->last = p;
402:
403: switch (p->type) {
1.77 schwarze 404: case (MDOC_TBL):
405: /* FALLTHROUGH */
1.1 kristaps 406: case (MDOC_TEXT):
407: if ( ! mdoc_valid_post(mdoc))
408: return(0);
409: break;
410: default:
411: break;
412: }
413:
414: return(1);
415: }
416:
417:
418: static struct mdoc_node *
1.37 schwarze 419: node_alloc(struct mdoc *m, int line, int pos,
420: enum mdoct tok, enum mdoc_type type)
1.1 kristaps 421: {
422: struct mdoc_node *p;
423:
1.32 schwarze 424: p = mandoc_calloc(1, sizeof(struct mdoc_node));
1.19 schwarze 425: p->sec = m->lastsec;
1.1 kristaps 426: p->line = line;
427: p->pos = pos;
428: p->tok = tok;
1.37 schwarze 429: p->type = type;
1.58 schwarze 430:
431: /* Flag analysis. */
432:
1.60 schwarze 433: if (MDOC_SYNOPSIS & m->flags)
434: p->flags |= MDOC_SYNPRETTY;
435: else
436: p->flags &= ~MDOC_SYNPRETTY;
1.47 schwarze 437: if (MDOC_NEWLINE & m->flags)
438: p->flags |= MDOC_LINE;
439: m->flags &= ~MDOC_NEWLINE;
1.58 schwarze 440:
1.1 kristaps 441: return(p);
442: }
443:
444:
445: int
1.37 schwarze 446: mdoc_tail_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
1.1 kristaps 447: {
448: struct mdoc_node *p;
449:
1.19 schwarze 450: p = node_alloc(m, line, pos, tok, MDOC_TAIL);
1.25 schwarze 451: if ( ! node_append(m, p))
452: return(0);
453: m->next = MDOC_NEXT_CHILD;
454: return(1);
1.1 kristaps 455: }
456:
457:
458: int
1.37 schwarze 459: mdoc_head_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
1.1 kristaps 460: {
461: struct mdoc_node *p;
462:
1.19 schwarze 463: assert(m->first);
464: assert(m->last);
1.1 kristaps 465:
1.19 schwarze 466: p = node_alloc(m, line, pos, tok, MDOC_HEAD);
1.25 schwarze 467: if ( ! node_append(m, p))
468: return(0);
469: m->next = MDOC_NEXT_CHILD;
470: return(1);
1.1 kristaps 471: }
472:
473:
474: int
1.37 schwarze 475: mdoc_body_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
1.1 kristaps 476: {
477: struct mdoc_node *p;
478:
1.19 schwarze 479: p = node_alloc(m, line, pos, tok, MDOC_BODY);
1.25 schwarze 480: if ( ! node_append(m, p))
481: return(0);
482: m->next = MDOC_NEXT_CHILD;
1.59 schwarze 483: return(1);
484: }
485:
486:
487: int
488: mdoc_endbody_alloc(struct mdoc *m, int line, int pos, enum mdoct tok,
489: struct mdoc_node *body, enum mdoc_endbody end)
490: {
491: struct mdoc_node *p;
492:
493: p = node_alloc(m, line, pos, tok, MDOC_BODY);
494: p->pending = body;
495: p->end = end;
496: if ( ! node_append(m, p))
497: return(0);
498: m->next = MDOC_NEXT_SIBLING;
1.25 schwarze 499: return(1);
1.1 kristaps 500: }
501:
502:
503: int
1.19 schwarze 504: mdoc_block_alloc(struct mdoc *m, int line, int pos,
1.37 schwarze 505: enum mdoct tok, struct mdoc_arg *args)
1.1 kristaps 506: {
507: struct mdoc_node *p;
508:
1.19 schwarze 509: p = node_alloc(m, line, pos, tok, MDOC_BLOCK);
1.4 schwarze 510: p->args = args;
511: if (p->args)
1.1 kristaps 512: (args->refcnt)++;
1.75 schwarze 513:
514: switch (tok) {
515: case (MDOC_Bd):
516: /* FALLTHROUGH */
517: case (MDOC_Bf):
518: /* FALLTHROUGH */
519: case (MDOC_Bl):
520: /* FALLTHROUGH */
521: case (MDOC_Rs):
522: p->norm = mandoc_calloc(1, sizeof(union mdoc_data));
523: break;
524: default:
525: break;
526: }
527:
1.25 schwarze 528: if ( ! node_append(m, p))
529: return(0);
530: m->next = MDOC_NEXT_CHILD;
531: return(1);
1.1 kristaps 532: }
533:
534:
535: int
1.19 schwarze 536: mdoc_elem_alloc(struct mdoc *m, int line, int pos,
1.37 schwarze 537: enum mdoct tok, struct mdoc_arg *args)
1.1 kristaps 538: {
539: struct mdoc_node *p;
540:
1.19 schwarze 541: p = node_alloc(m, line, pos, tok, MDOC_ELEM);
1.4 schwarze 542: p->args = args;
543: if (p->args)
1.1 kristaps 544: (args->refcnt)++;
1.75 schwarze 545:
546: switch (tok) {
547: case (MDOC_An):
548: p->norm = mandoc_calloc(1, sizeof(union mdoc_data));
549: break;
550: default:
551: break;
552: }
553:
1.25 schwarze 554: if ( ! node_append(m, p))
555: return(0);
556: m->next = MDOC_NEXT_CHILD;
557: return(1);
1.1 kristaps 558: }
559:
1.46 schwarze 560: int
561: mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
1.1 kristaps 562: {
1.19 schwarze 563: struct mdoc_node *n;
1.46 schwarze 564: size_t sv, len;
565:
566: len = strlen(p);
1.1 kristaps 567:
1.46 schwarze 568: n = node_alloc(m, line, pos, MDOC_MAX, MDOC_TEXT);
1.32 schwarze 569: n->string = mandoc_malloc(len + 1);
1.19 schwarze 570: sv = strlcpy(n->string, p, len + 1);
571:
572: /* Prohibit truncation. */
573: assert(sv < len + 1);
574:
1.25 schwarze 575: if ( ! node_append(m, n))
576: return(0);
1.46 schwarze 577:
1.25 schwarze 578: m->next = MDOC_NEXT_SIBLING;
579: return(1);
1.19 schwarze 580: }
581:
582:
1.61 schwarze 583: static void
1.1 kristaps 584: mdoc_node_free(struct mdoc_node *p)
585: {
1.61 schwarze 586:
1.75 schwarze 587: if (MDOC_BLOCK == p->type || MDOC_ELEM == p->type)
588: free(p->norm);
1.1 kristaps 589: if (p->string)
590: free(p->string);
591: if (p->args)
592: mdoc_argv_free(p->args);
593: free(p);
594: }
595:
596:
1.40 schwarze 597: static void
598: mdoc_node_unlink(struct mdoc *m, struct mdoc_node *n)
599: {
600:
601: /* Adjust siblings. */
602:
603: if (n->prev)
604: n->prev->next = n->next;
605: if (n->next)
606: n->next->prev = n->prev;
607:
608: /* Adjust parent. */
609:
610: if (n->parent) {
611: n->parent->nchild--;
612: if (n->parent->child == n)
613: n->parent->child = n->prev ? n->prev : n->next;
1.72 schwarze 614: if (n->parent->last == n)
615: n->parent->last = n->prev ? n->prev : NULL;
1.40 schwarze 616: }
617:
618: /* Adjust parse point, if applicable. */
619:
620: if (m && m->last == n) {
621: if (n->prev) {
622: m->last = n->prev;
623: m->next = MDOC_NEXT_SIBLING;
624: } else {
625: m->last = n->parent;
626: m->next = MDOC_NEXT_CHILD;
627: }
628: }
629:
630: if (m && m->first == n)
631: m->first = NULL;
632: }
633:
634:
1.1 kristaps 635: void
1.40 schwarze 636: mdoc_node_delete(struct mdoc *m, struct mdoc_node *p)
1.1 kristaps 637: {
638:
1.40 schwarze 639: while (p->child) {
640: assert(p->nchild);
641: mdoc_node_delete(m, p->child);
642: }
643: assert(0 == p->nchild);
1.1 kristaps 644:
1.40 schwarze 645: mdoc_node_unlink(m, p);
1.1 kristaps 646: mdoc_node_free(p);
647: }
648:
649:
650: /*
651: * Parse free-form text, that is, a line that does not begin with the
652: * control character.
653: */
654: static int
1.53 schwarze 655: mdoc_ptext(struct mdoc *m, int line, char *buf, int offs)
1.1 kristaps 656: {
1.56 schwarze 657: char *c, *ws, *end;
658: struct mdoc_node *n;
1.44 schwarze 659:
1.46 schwarze 660: /* No text before an initial macro. */
661:
1.76 schwarze 662: if (SEC_NONE == m->lastnamed) {
663: mdoc_pmsg(m, line, offs, MANDOCERR_NOTEXT);
664: return(1);
665: }
1.46 schwarze 666:
1.56 schwarze 667: assert(m->last);
668: n = m->last;
669:
670: /*
671: * Divert directly to list processing if we're encountering a
672: * columnar MDOC_BLOCK with or without a prior MDOC_BLOCK entry
673: * (a MDOC_BODY means it's already open, in which case we should
674: * process within its context in the normal way).
675: */
676:
677: if (MDOC_Bl == n->tok && MDOC_BODY == n->type &&
1.75 schwarze 678: LIST_column == n->norm->Bl.type) {
1.56 schwarze 679: /* `Bl' is open without any children. */
680: m->flags |= MDOC_FREECOL;
681: return(mdoc_macro(m, MDOC_It, line, offs, &offs, buf));
682: }
683:
684: if (MDOC_It == n->tok && MDOC_BLOCK == n->type &&
685: NULL != n->parent &&
686: MDOC_Bl == n->parent->tok &&
1.75 schwarze 687: LIST_column == n->parent->norm->Bl.type) {
1.56 schwarze 688: /* `Bl' has block-level `It' children. */
689: m->flags |= MDOC_FREECOL;
690: return(mdoc_macro(m, MDOC_It, line, offs, &offs, buf));
691: }
692:
1.52 schwarze 693: /*
694: * Search for the beginning of unescaped trailing whitespace (ws)
695: * and for the first character not to be output (end).
696: */
1.56 schwarze 697:
698: /* FIXME: replace with strcspn(). */
1.52 schwarze 699: ws = NULL;
1.53 schwarze 700: for (c = end = buf + offs; *c; c++) {
1.52 schwarze 701: switch (*c) {
1.55 schwarze 702: case '-':
703: if (mandoc_hyph(buf + offs, c))
704: *c = ASCII_HYPH;
1.56 schwarze 705: ws = NULL;
1.55 schwarze 706: break;
1.52 schwarze 707: case ' ':
708: if (NULL == ws)
709: ws = c;
710: continue;
711: case '\t':
712: /*
713: * Always warn about trailing tabs,
714: * even outside literal context,
715: * where they should be put on the next line.
716: */
717: if (NULL == ws)
718: ws = c;
719: /*
720: * Strip trailing tabs in literal context only;
721: * outside, they affect the next line.
722: */
723: if (MDOC_LITERAL & m->flags)
724: continue;
725: break;
726: case '\\':
727: /* Skip the escaped character, too, if any. */
728: if (c[1])
729: c++;
730: /* FALLTHROUGH */
731: default:
732: ws = NULL;
733: break;
734: }
735: end = c + 1;
736: }
737: *end = '\0';
1.19 schwarze 738:
1.52 schwarze 739: if (ws)
1.76 schwarze 740: mdoc_pmsg(m, line, (int)(ws-buf), MANDOCERR_EOLNSPACE);
1.34 schwarze 741:
1.53 schwarze 742: if ('\0' == buf[offs] && ! (MDOC_LITERAL & m->flags)) {
1.76 schwarze 743: mdoc_pmsg(m, line, (int)(c-buf), MANDOCERR_NOBLANKLN);
1.46 schwarze 744:
1.40 schwarze 745: /*
1.66 schwarze 746: * Insert a `sp' in the case of a blank line. Technically,
1.46 schwarze 747: * blank lines aren't allowed, but enough manuals assume this
748: * behaviour that we want to work around it.
1.40 schwarze 749: */
1.66 schwarze 750: if ( ! mdoc_elem_alloc(m, line, offs, MDOC_sp, NULL))
1.42 schwarze 751: return(0);
1.46 schwarze 752:
1.42 schwarze 753: m->next = MDOC_NEXT_SIBLING;
754: return(1);
1.38 schwarze 755: }
1.1 kristaps 756:
1.53 schwarze 757: if ( ! mdoc_word_alloc(m, line, offs, buf+offs))
1.1 kristaps 758: return(0);
759:
1.52 schwarze 760: if (MDOC_LITERAL & m->flags)
761: return(1);
762:
1.35 schwarze 763: /*
1.48 schwarze 764: * End-of-sentence check. If the last character is an unescaped
765: * EOS character, then flag the node as being the end of a
766: * sentence. The front-end will know how to interpret this.
1.35 schwarze 767: */
768:
1.52 schwarze 769: assert(buf < end);
1.48 schwarze 770:
1.62 schwarze 771: if (mandoc_eos(buf+offs, (size_t)(end-buf-offs), 0))
1.48 schwarze 772: m->last->flags |= MDOC_EOS;
773:
1.1 kristaps 774: return(1);
775: }
1.19 schwarze 776:
1.1 kristaps 777:
778: /*
779: * Parse a macro line, that is, a line beginning with the control
780: * character.
781: */
1.61 schwarze 782: static int
1.53 schwarze 783: mdoc_pmacro(struct mdoc *m, int ln, char *buf, int offs)
1.1 kristaps 784: {
1.56 schwarze 785: enum mdoct tok;
1.83 ! schwarze 786: int i, sv;
1.56 schwarze 787: char mac[5];
788: struct mdoc_node *n;
1.1 kristaps 789:
1.83 ! schwarze 790: /* Empty post-control lines are ignored. */
1.1 kristaps 791:
1.83 ! schwarze 792: if ('"' == buf[offs]) {
! 793: mdoc_pmsg(m, ln, offs, MANDOCERR_BADCOMMENT);
! 794: return(1);
! 795: } else if ('\0' == buf[offs])
1.1 kristaps 796: return(1);
797:
1.83 ! schwarze 798: sv = offs;
1.47 schwarze 799:
1.63 schwarze 800: /*
1.64 schwarze 801: * Copy the first word into a nil-terminated buffer.
802: * Stop copying when a tab, space, or eoln is encountered.
1.63 schwarze 803: */
1.1 kristaps 804:
1.83 ! schwarze 805: i = 0;
! 806: while (i < 4 && '\0' != buf[offs] &&
! 807: ' ' != buf[offs] && '\t' != buf[offs])
! 808: mac[i++] = buf[offs++];
! 809:
! 810: mac[i] = '\0';
! 811:
! 812: tok = (i > 1 || i < 4) ? mdoc_hash_find(mac) : MDOC_MAX;
1.1 kristaps 813:
1.65 schwarze 814: if (MDOC_MAX == tok) {
1.83 ! schwarze 815: mandoc_vmsg(MANDOCERR_MACRO, m->parse,
! 816: ln, sv, "%s", buf + sv - 1);
1.1 kristaps 817: return(1);
818: }
819:
1.63 schwarze 820: /* Disregard the first trailing tab, if applicable. */
821:
1.83 ! schwarze 822: if ('\t' == buf[offs])
! 823: offs++;
1.63 schwarze 824:
825: /* Jump to the next non-whitespace word. */
1.1 kristaps 826:
1.83 ! schwarze 827: while (buf[offs] && ' ' == buf[offs])
! 828: offs++;
1.34 schwarze 829:
1.46 schwarze 830: /*
831: * Trailing whitespace. Note that tabs are allowed to be passed
832: * into the parser as "text", so we only warn about spaces here.
833: */
1.34 schwarze 834:
1.83 ! schwarze 835: if ('\0' == buf[offs] && ' ' == buf[offs - 1])
! 836: mdoc_pmsg(m, ln, offs - 1, MANDOCERR_EOLNSPACE);
1.1 kristaps 837:
1.56 schwarze 838: /*
839: * If an initial macro or a list invocation, divert directly
840: * into macro processing.
841: */
842:
843: if (NULL == m->last || MDOC_It == tok || MDOC_El == tok) {
1.83 ! schwarze 844: if ( ! mdoc_macro(m, tok, ln, sv, &offs, buf))
1.56 schwarze 845: goto err;
846: return(1);
847: }
848:
849: n = m->last;
850: assert(m->last);
851:
852: /*
853: * If the first macro of a `Bl -column', open an `It' block
854: * context around the parsed macro.
855: */
856:
857: if (MDOC_Bl == n->tok && MDOC_BODY == n->type &&
1.75 schwarze 858: LIST_column == n->norm->Bl.type) {
1.56 schwarze 859: m->flags |= MDOC_FREECOL;
1.58 schwarze 860: if ( ! mdoc_macro(m, MDOC_It, ln, sv, &sv, buf))
1.56 schwarze 861: goto err;
862: return(1);
863: }
864:
865: /*
866: * If we're following a block-level `It' within a `Bl -column'
867: * context (perhaps opened in the above block or in ptext()),
868: * then open an `It' block context around the parsed macro.
1.24 schwarze 869: */
1.56 schwarze 870:
871: if (MDOC_It == n->tok && MDOC_BLOCK == n->type &&
872: NULL != n->parent &&
873: MDOC_Bl == n->parent->tok &&
1.75 schwarze 874: LIST_column == n->parent->norm->Bl.type) {
1.56 schwarze 875: m->flags |= MDOC_FREECOL;
876: if ( ! mdoc_macro(m, MDOC_It, ln, sv, &sv, buf))
877: goto err;
878: return(1);
879: }
880:
881: /* Normal processing of a macro. */
882:
1.83 ! schwarze 883: if ( ! mdoc_macro(m, tok, ln, sv, &offs, buf))
1.1 kristaps 884: goto err;
885:
886: return(1);
887:
888: err: /* Error out. */
889:
890: m->flags |= MDOC_HALT;
891: return(0);
892: }
1.24 schwarze 893:
1.83 ! schwarze 894: enum mdelim
! 895: mdoc_isdelim(const char *p)
! 896: {
! 897:
! 898: if ('\0' == p[0])
! 899: return(DELIM_NONE);
! 900:
! 901: if ('\0' == p[1])
! 902: switch (p[0]) {
! 903: case('('):
! 904: /* FALLTHROUGH */
! 905: case('['):
! 906: return(DELIM_OPEN);
! 907: case('|'):
! 908: return(DELIM_MIDDLE);
! 909: case('.'):
! 910: /* FALLTHROUGH */
! 911: case(','):
! 912: /* FALLTHROUGH */
! 913: case(';'):
! 914: /* FALLTHROUGH */
! 915: case(':'):
! 916: /* FALLTHROUGH */
! 917: case('?'):
! 918: /* FALLTHROUGH */
! 919: case('!'):
! 920: /* FALLTHROUGH */
! 921: case(')'):
! 922: /* FALLTHROUGH */
! 923: case(']'):
! 924: return(DELIM_CLOSE);
! 925: default:
! 926: return(DELIM_NONE);
! 927: }
! 928:
! 929: if ('\\' != p[0])
! 930: return(DELIM_NONE);
1.24 schwarze 931:
1.83 ! schwarze 932: if (0 == strcmp(p + 1, "."))
! 933: return(DELIM_CLOSE);
! 934: if (0 == strcmp(p + 1, "*(Ba"))
! 935: return(DELIM_MIDDLE);
! 936:
! 937: return(DELIM_NONE);
! 938: }
![[BACK]](/icons/back.gif){kind=icon}
Return to mdoc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / mandoc