mdoc.c revision 1.1.1.6 
1/*	$Vendor-Id: mdoc.c,v 1.121 2010/04/06 11:33:00 kristaps Exp $ */
2/*
3 * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
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 above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17#ifdef HAVE_CONFIG_H
18#include "config.h"
19#endif
20
21#include <sys/types.h>
22
23#include <assert.h>
24#include <ctype.h>
25#include <stdarg.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
29#include <time.h>
30
31#include "libmdoc.h"
32#include "libmandoc.h"
33
34const	char *const __mdoc_merrnames[MERRMAX] = {
35	"trailing whitespace", /* ETAILWS */
36	"unexpected quoted parameter", /* EQUOTPARM */
37	"unterminated quoted parameter", /* EQUOTTERM */
38	"argument parameter suggested", /* EARGVAL */
39	"macro disallowed in prologue", /* EBODYPROL */
40	"macro disallowed in body", /* EPROLBODY */
41	"text disallowed in prologue", /* ETEXTPROL */
42	"blank line disallowed", /* ENOBLANK */
43	"text parameter too long", /* ETOOLONG */
44	"invalid escape sequence", /* EESCAPE */
45	"invalid character", /* EPRINT */
46	"document has no body", /* ENODAT */
47	"document has no prologue", /* ENOPROLOGUE */
48	"expected line arguments", /* ELINE */
49	"invalid AT&T argument", /* EATT */
50	"default name not yet set", /* ENAME */
51	"missing list type", /* ELISTTYPE */
52	"missing display type", /* EDISPTYPE */
53	"too many display types", /* EMULTIDISP */
54	"too many list types", /* EMULTILIST */
55	"NAME section must be first", /* ESECNAME */
56	"badly-formed NAME section", /* ENAMESECINC */
57	"argument repeated", /* EARGREP */
58	"expected boolean parameter", /* EBOOL */
59	"inconsistent column syntax", /* ECOLMIS */
60	"nested display invalid", /* ENESTDISP */
61	"width argument missing", /* EMISSWIDTH */
62	"invalid section for this manual section", /* EWRONGMSEC */
63	"section out of conventional order", /* ESECOOO */
64	"section repeated", /* ESECREP */
65	"invalid standard argument", /* EBADSTAND */
66	"multi-line arguments discouraged", /* ENOMULTILINE */
67	"multi-line arguments suggested", /* EMULTILINE */
68	"line arguments discouraged", /* ENOLINE */
69	"prologue macro out of conventional order", /* EPROLOOO */
70	"prologue macro repeated", /* EPROLREP */
71	"invalid manual section", /* EBADMSEC */
72	"invalid section", /* EBADSEC */
73	"invalid font mode", /* EFONT */
74	"invalid date syntax", /* EBADDATE */
75	"invalid number format", /* ENUMFMT */
76	"superfluous width argument", /* ENOWIDTH */
77	"system: utsname error", /* EUTSNAME */
78	"obsolete macro", /* EOBS */
79	"end-of-line scope violation", /* EIMPBRK */
80	"empty macro ignored", /* EIGNE */
81	"unclosed explicit scope", /* EOPEN */
82	"unterminated quoted phrase", /* EQUOTPHR */
83	"closure macro without prior context", /* ENOCTX */
84	"no description found for library", /* ELIB */
85	"bad child for parent context", /* EBADCHILD */
86	"list arguments preceding type", /* ENOTYPE */
87};
88
89const	char *const __mdoc_macronames[MDOC_MAX] = {
90	"Ap",		"Dd",		"Dt",		"Os",
91	"Sh",		"Ss",		"Pp",		"D1",
92	"Dl",		"Bd",		"Ed",		"Bl",
93	"El",		"It",		"Ad",		"An",
94	"Ar",		"Cd",		"Cm",		"Dv",
95	"Er",		"Ev",		"Ex",		"Fa",
96	"Fd",		"Fl",		"Fn",		"Ft",
97	"Ic",		"In",		"Li",		"Nd",
98	"Nm",		"Op",		"Ot",		"Pa",
99	"Rv",		"St",		"Va",		"Vt",
100	/* LINTED */
101	"Xr",		"%A",		"%B",		"%D",
102	/* LINTED */
103	"%I",		"%J",		"%N",		"%O",
104	/* LINTED */
105	"%P",		"%R",		"%T",		"%V",
106	"Ac",		"Ao",		"Aq",		"At",
107	"Bc",		"Bf",		"Bo",		"Bq",
108	"Bsx",		"Bx",		"Db",		"Dc",
109	"Do",		"Dq",		"Ec",		"Ef",
110	"Em",		"Eo",		"Fx",		"Ms",
111	"No",		"Ns",		"Nx",		"Ox",
112	"Pc",		"Pf",		"Po",		"Pq",
113	"Qc",		"Ql",		"Qo",		"Qq",
114	"Re",		"Rs",		"Sc",		"So",
115	"Sq",		"Sm",		"Sx",		"Sy",
116	"Tn",		"Ux",		"Xc",		"Xo",
117	"Fo",		"Fc",		"Oo",		"Oc",
118	"Bk",		"Ek",		"Bt",		"Hf",
119	"Fr",		"Ud",		"Lb",		"Lp",
120	"Lk",		"Mt",		"Brq",		"Bro",
121	/* LINTED */
122	"Brc",		"%C",		"Es",		"En",
123	/* LINTED */
124	"Dx",		"%Q",		"br",		"sp",
125	/* LINTED */
126	"%U"
127	};
128
129const	char *const __mdoc_argnames[MDOC_ARG_MAX] = {
130	"split",		"nosplit",		"ragged",
131	"unfilled",		"literal",		"file",
132	"offset",		"bullet",		"dash",
133	"hyphen",		"item",			"enum",
134	"tag",			"diag",			"hang",
135	"ohang",		"inset",		"column",
136	"width",		"compact",		"std",
137	"filled",		"words",		"emphasis",
138	"symbolic",		"nested",		"centered"
139	};
140
141const	char * const *mdoc_macronames = __mdoc_macronames;
142const	char * const *mdoc_argnames = __mdoc_argnames;
143
144static	void		  mdoc_node_free(struct mdoc_node *);
145static	void		  mdoc_node_unlink(struct mdoc *,
146				struct mdoc_node *);
147static	void		  mdoc_free1(struct mdoc *);
148static	void		  mdoc_alloc1(struct mdoc *);
149static	struct mdoc_node *node_alloc(struct mdoc *, int, int,
150				enum mdoct, enum mdoc_type);
151static	int		  node_append(struct mdoc *,
152				struct mdoc_node *);
153static	int		  parsetext(struct mdoc *, int, char *);
154static	int		  parsemacro(struct mdoc *, int, char *);
155static	int		  macrowarn(struct mdoc *, int, const char *);
156static	int		  pstring(struct mdoc *, int, int,
157				const char *, size_t);
158
159const struct mdoc_node *
160mdoc_node(const struct mdoc *m)
161{
162
163	return(MDOC_HALT & m->flags ? NULL : m->first);
164}
165
166
167const struct mdoc_meta *
168mdoc_meta(const struct mdoc *m)
169{
170
171	return(MDOC_HALT & m->flags ? NULL : &m->meta);
172}
173
174
175/*
176 * Frees volatile resources (parse tree, meta-data, fields).
177 */
178static void
179mdoc_free1(struct mdoc *mdoc)
180{
181
182	if (mdoc->first)
183		mdoc_node_delete(mdoc, mdoc->first);
184	if (mdoc->meta.title)
185		free(mdoc->meta.title);
186	if (mdoc->meta.os)
187		free(mdoc->meta.os);
188	if (mdoc->meta.name)
189		free(mdoc->meta.name);
190	if (mdoc->meta.arch)
191		free(mdoc->meta.arch);
192	if (mdoc->meta.vol)
193		free(mdoc->meta.vol);
194}
195
196
197/*
198 * Allocate all volatile resources (parse tree, meta-data, fields).
199 */
200static void
201mdoc_alloc1(struct mdoc *mdoc)
202{
203
204	memset(&mdoc->meta, 0, sizeof(struct mdoc_meta));
205	mdoc->flags = 0;
206	mdoc->lastnamed = mdoc->lastsec = SEC_NONE;
207	mdoc->last = mandoc_calloc(1, sizeof(struct mdoc_node));
208	mdoc->first = mdoc->last;
209	mdoc->last->type = MDOC_ROOT;
210	mdoc->next = MDOC_NEXT_CHILD;
211}
212
213
214/*
215 * Free up volatile resources (see mdoc_free1()) then re-initialises the
216 * data with mdoc_alloc1().  After invocation, parse data has been reset
217 * and the parser is ready for re-invocation on a new tree; however,
218 * cross-parse non-volatile data is kept intact.
219 */
220void
221mdoc_reset(struct mdoc *mdoc)
222{
223
224	mdoc_free1(mdoc);
225	mdoc_alloc1(mdoc);
226}
227
228
229/*
230 * Completely free up all volatile and non-volatile parse resources.
231 * After invocation, the pointer is no longer usable.
232 */
233void
234mdoc_free(struct mdoc *mdoc)
235{
236
237	mdoc_free1(mdoc);
238	free(mdoc);
239}
240
241
242/*
243 * Allocate volatile and non-volatile parse resources.
244 */
245struct mdoc *
246mdoc_alloc(void *data, int pflags, const struct mdoc_cb *cb)
247{
248	struct mdoc	*p;
249
250	p = mandoc_calloc(1, sizeof(struct mdoc));
251
252	if (cb)
253		memcpy(&p->cb, cb, sizeof(struct mdoc_cb));
254
255	p->data = data;
256	p->pflags = pflags;
257
258	mdoc_hash_init();
259	mdoc_alloc1(p);
260	return(p);
261}
262
263
264/*
265 * Climb back up the parse tree, validating open scopes.  Mostly calls
266 * through to macro_end() in macro.c.
267 */
268int
269mdoc_endparse(struct mdoc *m)
270{
271
272	if (MDOC_HALT & m->flags)
273		return(0);
274	else if (mdoc_macroend(m))
275		return(1);
276	m->flags |= MDOC_HALT;
277	return(0);
278}
279
280
281/*
282 * Main parse routine.  Parses a single line -- really just hands off to
283 * the macro (parsemacro()) or text parser (parsetext()).
284 */
285int
286mdoc_parseln(struct mdoc *m, int ln, char *buf)
287{
288
289	if (MDOC_HALT & m->flags)
290		return(0);
291
292	return('.' == *buf ? parsemacro(m, ln, buf) :
293			parsetext(m, ln, buf));
294}
295
296
297int
298mdoc_verr(struct mdoc *mdoc, int ln, int pos,
299		const char *fmt, ...)
300{
301	char		 buf[256];
302	va_list		 ap;
303
304	if (NULL == mdoc->cb.mdoc_err)
305		return(0);
306
307	va_start(ap, fmt);
308	(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
309	va_end(ap);
310
311	return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf));
312}
313
314
315int
316mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...)
317{
318	char		 buf[256];
319	va_list		 ap;
320
321	if (NULL == mdoc->cb.mdoc_warn)
322		return(0);
323
324	va_start(ap, fmt);
325	(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
326	va_end(ap);
327
328	return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf));
329}
330
331
332int
333mdoc_err(struct mdoc *m, int line, int pos, int iserr, enum merr type)
334{
335	const char	*p;
336
337	p = __mdoc_merrnames[(int)type];
338	assert(p);
339
340	if (iserr)
341		return(mdoc_verr(m, line, pos, p));
342
343	return(mdoc_vwarn(m, line, pos, p));
344}
345
346
347int
348mdoc_macro(struct mdoc *m, enum mdoct tok,
349		int ln, int pp, int *pos, char *buf)
350{
351
352	assert(tok < MDOC_MAX);
353	/*
354	 * If we're in the prologue, deny "body" macros.  Similarly, if
355	 * we're in the body, deny prologue calls.
356	 */
357	if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&
358			MDOC_PBODY & m->flags) {
359		if ( ! mdoc_pwarn(m, ln, pp, EBODYPROL))
360			return(0);
361		/*
362		 * FIXME: do this in mdoc_action.c.
363		 */
364		if (NULL == m->meta.title)
365			m->meta.title = mandoc_strdup("unknown");
366		if (NULL == m->meta.vol)
367			m->meta.vol = mandoc_strdup("local");
368		if (NULL == m->meta.os)
369			m->meta.os = mandoc_strdup("local");
370		if (0 == m->meta.date)
371			m->meta.date = time(NULL);
372		m->flags |= MDOC_PBODY;
373	}
374	if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) &&
375			! (MDOC_PBODY & m->flags))
376		return(mdoc_perr(m, ln, pp, EBODYPROL));
377
378	return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));
379}
380
381
382static int
383node_append(struct mdoc *mdoc, struct mdoc_node *p)
384{
385
386	assert(mdoc->last);
387	assert(mdoc->first);
388	assert(MDOC_ROOT != p->type);
389
390	switch (mdoc->next) {
391	case (MDOC_NEXT_SIBLING):
392		mdoc->last->next = p;
393		p->prev = mdoc->last;
394		p->parent = mdoc->last->parent;
395		break;
396	case (MDOC_NEXT_CHILD):
397		mdoc->last->child = p;
398		p->parent = mdoc->last;
399		break;
400	default:
401		abort();
402		/* NOTREACHED */
403	}
404
405	p->parent->nchild++;
406
407	if ( ! mdoc_valid_pre(mdoc, p))
408		return(0);
409	if ( ! mdoc_action_pre(mdoc, p))
410		return(0);
411
412	switch (p->type) {
413	case (MDOC_HEAD):
414		assert(MDOC_BLOCK == p->parent->type);
415		p->parent->head = p;
416		break;
417	case (MDOC_TAIL):
418		assert(MDOC_BLOCK == p->parent->type);
419		p->parent->tail = p;
420		break;
421	case (MDOC_BODY):
422		assert(MDOC_BLOCK == p->parent->type);
423		p->parent->body = p;
424		break;
425	default:
426		break;
427	}
428
429	mdoc->last = p;
430
431	switch (p->type) {
432	case (MDOC_TEXT):
433		if ( ! mdoc_valid_post(mdoc))
434			return(0);
435		if ( ! mdoc_action_post(mdoc))
436			return(0);
437		break;
438	default:
439		break;
440	}
441
442	return(1);
443}
444
445
446static struct mdoc_node *
447node_alloc(struct mdoc *m, int line, int pos,
448		enum mdoct tok, enum mdoc_type type)
449{
450	struct mdoc_node *p;
451
452	p = mandoc_calloc(1, sizeof(struct mdoc_node));
453	p->sec = m->lastsec;
454	p->line = line;
455	p->pos = pos;
456	p->tok = tok;
457	p->type = type;
458
459	return(p);
460}
461
462
463int
464mdoc_tail_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
465{
466	struct mdoc_node *p;
467
468	p = node_alloc(m, line, pos, tok, MDOC_TAIL);
469	if ( ! node_append(m, p))
470		return(0);
471	m->next = MDOC_NEXT_CHILD;
472	return(1);
473}
474
475
476int
477mdoc_head_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
478{
479	struct mdoc_node *p;
480
481	assert(m->first);
482	assert(m->last);
483
484	p = node_alloc(m, line, pos, tok, MDOC_HEAD);
485	if ( ! node_append(m, p))
486		return(0);
487	m->next = MDOC_NEXT_CHILD;
488	return(1);
489}
490
491
492int
493mdoc_body_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
494{
495	struct mdoc_node *p;
496
497	p = node_alloc(m, line, pos, tok, MDOC_BODY);
498	if ( ! node_append(m, p))
499		return(0);
500	m->next = MDOC_NEXT_CHILD;
501	return(1);
502}
503
504
505int
506mdoc_block_alloc(struct mdoc *m, int line, int pos,
507		enum mdoct tok, struct mdoc_arg *args)
508{
509	struct mdoc_node *p;
510
511	p = node_alloc(m, line, pos, tok, MDOC_BLOCK);
512	p->args = args;
513	if (p->args)
514		(args->refcnt)++;
515	if ( ! node_append(m, p))
516		return(0);
517	m->next = MDOC_NEXT_CHILD;
518	return(1);
519}
520
521
522int
523mdoc_elem_alloc(struct mdoc *m, int line, int pos,
524		enum mdoct tok, struct mdoc_arg *args)
525{
526	struct mdoc_node *p;
527
528	p = node_alloc(m, line, pos, tok, MDOC_ELEM);
529	p->args = args;
530	if (p->args)
531		(args->refcnt)++;
532	if ( ! node_append(m, p))
533		return(0);
534	m->next = MDOC_NEXT_CHILD;
535	return(1);
536}
537
538
539static int
540pstring(struct mdoc *m, int line, int pos, const char *p, size_t len)
541{
542	struct mdoc_node *n;
543	size_t		  sv;
544
545	n = node_alloc(m, line, pos, -1, MDOC_TEXT);
546	n->string = mandoc_malloc(len + 1);
547	sv = strlcpy(n->string, p, len + 1);
548
549	/* Prohibit truncation. */
550	assert(sv < len + 1);
551
552	if ( ! node_append(m, n))
553		return(0);
554	m->next = MDOC_NEXT_SIBLING;
555	return(1);
556}
557
558
559int
560mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
561{
562
563	return(pstring(m, line, pos, p, strlen(p)));
564}
565
566
567void
568mdoc_node_free(struct mdoc_node *p)
569{
570
571	if (p->string)
572		free(p->string);
573	if (p->args)
574		mdoc_argv_free(p->args);
575	free(p);
576}
577
578
579static void
580mdoc_node_unlink(struct mdoc *m, struct mdoc_node *n)
581{
582
583	/* Adjust siblings. */
584
585	if (n->prev)
586		n->prev->next = n->next;
587	if (n->next)
588		n->next->prev = n->prev;
589
590	/* Adjust parent. */
591
592	if (n->parent) {
593		n->parent->nchild--;
594		if (n->parent->child == n)
595			n->parent->child = n->prev ? n->prev : n->next;
596	}
597
598	/* Adjust parse point, if applicable. */
599
600	if (m && m->last == n) {
601		if (n->prev) {
602			m->last = n->prev;
603			m->next = MDOC_NEXT_SIBLING;
604		} else {
605			m->last = n->parent;
606			m->next = MDOC_NEXT_CHILD;
607		}
608	}
609
610	if (m && m->first == n)
611		m->first = NULL;
612}
613
614
615void
616mdoc_node_delete(struct mdoc *m, struct mdoc_node *p)
617{
618
619	while (p->child) {
620		assert(p->nchild);
621		mdoc_node_delete(m, p->child);
622	}
623	assert(0 == p->nchild);
624
625	mdoc_node_unlink(m, p);
626	mdoc_node_free(p);
627}
628
629
630/*
631 * Parse free-form text, that is, a line that does not begin with the
632 * control character.
633 */
634static int
635parsetext(struct mdoc *m, int line, char *buf)
636{
637	int		 i, j;
638	char		 sv;
639
640	if (SEC_NONE == m->lastnamed)
641		return(mdoc_perr(m, line, 0, ETEXTPROL));
642
643	/*
644	 * If in literal mode, then pass the buffer directly to the
645	 * back-end, as it should be preserved as a single term.
646	 */
647
648	if (MDOC_LITERAL & m->flags)
649		return(mdoc_word_alloc(m, line, 0, buf));
650
651	/* Disallow blank/white-space lines in non-literal mode. */
652
653	for (i = 0; ' ' == buf[i]; i++)
654		/* Skip leading whitespace. */ ;
655
656	if ('\0' == buf[i]) {
657		if ( ! mdoc_pwarn(m, line, 0, ENOBLANK))
658			return(0);
659		/*
660		 * Assume that a `Pp' should be inserted in the case of
661		 * a blank line.  Technically, blank lines aren't
662		 * allowed, but enough manuals assume this behaviour
663		 * that we want to work around it.
664		 */
665		if ( ! mdoc_elem_alloc(m, line, 0, MDOC_Pp, NULL))
666			return(0);
667	}
668
669	/*
670	 * Break apart a free-form line into tokens.  Spaces are
671	 * stripped out of the input.
672	 */
673
674	for (j = i; buf[i]; i++) {
675		if (' ' != buf[i])
676			continue;
677
678		/* Escaped whitespace. */
679		if (i && ' ' == buf[i] && '\\' == buf[i - 1])
680			continue;
681
682		sv = buf[i];
683		buf[i++] = '\0';
684
685		if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
686			return(0);
687
688		/* Trailing whitespace?  Check at overwritten byte. */
689
690		if (' ' == sv && '\0' == buf[i])
691			if ( ! mdoc_pwarn(m, line, i - 1, ETAILWS))
692				return(0);
693
694		for ( ; ' ' == buf[i]; i++)
695			/* Skip trailing whitespace. */ ;
696
697		j = i;
698
699		/* Trailing whitespace? */
700
701		if (' ' == buf[i - 1] && '\0' == buf[i])
702			if ( ! mdoc_pwarn(m, line, i - 1, ETAILWS))
703				return(0);
704
705		if ('\0' == buf[i])
706			break;
707	}
708
709	if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
710		return(0);
711
712	m->next = MDOC_NEXT_SIBLING;
713	return(1);
714}
715
716
717
718static int
719macrowarn(struct mdoc *m, int ln, const char *buf)
720{
721	if ( ! (MDOC_IGN_MACRO & m->pflags))
722		return(mdoc_verr(m, ln, 0,
723				"unknown macro: %s%s",
724				buf, strlen(buf) > 3 ? "..." : ""));
725	return(mdoc_vwarn(m, ln, 0, "unknown macro: %s%s",
726				buf, strlen(buf) > 3 ? "..." : ""));
727}
728
729
730/*
731 * Parse a macro line, that is, a line beginning with the control
732 * character.
733 */
734int
735parsemacro(struct mdoc *m, int ln, char *buf)
736{
737	int		  i, j, c;
738	char		  mac[5];
739
740	/* Empty lines are ignored. */
741
742	if ('\0' == buf[1])
743		return(1);
744
745	i = 1;
746
747	/* Accept whitespace after the initial control char. */
748
749	if (' ' == buf[i]) {
750		i++;
751		while (buf[i] && ' ' == buf[i])
752			i++;
753		if ('\0' == buf[i])
754			return(1);
755	}
756
757	/* Copy the first word into a nil-terminated buffer. */
758
759	for (j = 0; j < 4; j++, i++) {
760		if ('\0' == (mac[j] = buf[i]))
761			break;
762		else if (' ' == buf[i])
763			break;
764
765		/* Check for invalid characters. */
766
767		if (isgraph((u_char)buf[i]))
768			continue;
769		return(mdoc_perr(m, ln, i, EPRINT));
770	}
771
772	mac[j] = 0;
773
774	if (j == 4 || j < 2) {
775		if ( ! macrowarn(m, ln, mac))
776			goto err;
777		return(1);
778	}
779
780	if (MDOC_MAX == (c = mdoc_hash_find(mac))) {
781		if ( ! macrowarn(m, ln, mac))
782			goto err;
783		return(1);
784	}
785
786	/* The macro is sane.  Jump to the next word. */
787
788	while (buf[i] && ' ' == buf[i])
789		i++;
790
791	/* Trailing whitespace? */
792
793	if ('\0' == buf[i] && ' ' == buf[i - 1])
794		if ( ! mdoc_pwarn(m, ln, i - 1, ETAILWS))
795			goto err;
796
797	/*
798	 * Begin recursive parse sequence.  Since we're at the start of
799	 * the line, we don't need to do callable/parseable checks.
800	 */
801	if ( ! mdoc_macro(m, c, ln, 1, &i, buf))
802		goto err;
803
804	return(1);
805
806err:	/* Error out. */
807
808	m->flags |= MDOC_HALT;
809	return(0);
810}
811
812
813