=================================================================== RCS file: /cvs/mandoc/mdoc.c,v retrieving revision 1.75 retrieving revision 1.88 diff -u -p -r1.75 -r1.88 --- mandoc/mdoc.c 2009/04/12 19:45:26 1.75 +++ mandoc/mdoc.c 2009/07/06 13:04:52 1.88 @@ -1,6 +1,6 @@ -/* $Id: mdoc.c,v 1.75 2009/04/12 19:45:26 kristaps Exp $ */ +/* $Id: mdoc.c,v 1.88 2009/07/06 13:04:52 kristaps Exp $ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons + * Copyright (c) 2008, 2009 Kristaps Dzonsons * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -23,18 +23,8 @@ #include "libmdoc.h" -enum merr { - ENOCALL, - EBODYPROL, - EPROLBODY, - ESPACE, - ETEXTPROL, - ENOBLANK, - EMALLOC -}; - const char *const __mdoc_macronames[MDOC_MAX] = { - "\\\"", "Dd", "Dt", "Os", + "Ap", "Dd", "Dt", "Os", "Sh", "Ss", "Pp", "D1", "Dl", "Bd", "Ed", "Bl", "El", "It", "Ad", "An", @@ -63,12 +53,12 @@ const char *const __mdoc_macronames[MDOC_MAX] = { "Tn", "Ux", "Xc", "Xo", "Fo", "Fc", "Oo", "Oc", "Bk", "Ek", "Bt", "Hf", - "Fr", "Ud", "Lb", "Ap", - "Lp", "Lk", "Mt", "Brq", + "Fr", "Ud", "Lb", "Lp", + "Lk", "Mt", "Brq", "Bro", /* LINTED */ - "Bro", "Brc", "\%C", "Es", + "Brc", "\%C", "Es", "En", /* LINTED */ - "En", "Dx", "\%Q" + "Dx", "\%Q" }; const char *const __mdoc_argnames[MDOC_ARG_MAX] = { @@ -95,13 +85,8 @@ static int node_append(struct mdoc *, static int parsetext(struct mdoc *, int, char *); static int parsemacro(struct mdoc *, int, char *); static int macrowarn(struct mdoc *, int, const char *); -static int perr(struct mdoc *, int, int, enum merr); -#define verr(m, t) perr((m), (m)->last->line, (m)->last->pos, (t)) -/* - * Get the first (root) node of the parse tree. - */ const struct mdoc_node * mdoc_node(const struct mdoc *m) { @@ -118,6 +103,9 @@ mdoc_meta(const struct mdoc *m) } +/* + * Frees volatile resources (parse tree, meta-data, fields). + */ static void mdoc_free1(struct mdoc *mdoc) { @@ -137,13 +125,16 @@ mdoc_free1(struct mdoc *mdoc) } +/* + * Allocate all volatile resources (parse tree, meta-data, fields). + */ static int mdoc_alloc1(struct mdoc *mdoc) { bzero(&mdoc->meta, sizeof(struct mdoc_meta)); mdoc->flags = 0; - mdoc->lastnamed = mdoc->lastsec = 0; + mdoc->lastnamed = mdoc->lastsec = SEC_NONE; mdoc->last = calloc(1, sizeof(struct mdoc_node)); if (NULL == mdoc->last) return(0); @@ -156,9 +147,10 @@ mdoc_alloc1(struct mdoc *mdoc) /* - * Free up all resources contributed by a parse: the node tree, - * meta-data and so on. Then reallocate the root node for another - * parse. + * Free up volatile resources (see mdoc_free1()) then re-initialises the + * data with mdoc_alloc1(). After invocation, parse data has been reset + * and the parser is ready for re-invocation on a new tree; however, + * cross-parse non-volatile data is kept intact. */ int mdoc_reset(struct mdoc *mdoc) @@ -170,7 +162,8 @@ mdoc_reset(struct mdoc *mdoc) /* - * Completely free up all resources. + * Completely free up all volatile and non-volatile parse resources. + * After invocation, the pointer is no longer usable. */ void mdoc_free(struct mdoc *mdoc) @@ -183,6 +176,9 @@ mdoc_free(struct mdoc *mdoc) } +/* + * Allocate volatile and non-volatile parse resources. + */ struct mdoc * mdoc_alloc(void *data, int pflags, const struct mdoc_cb *cb) { @@ -209,7 +205,7 @@ mdoc_alloc(void *data, int pflags, const struct mdoc_c /* * Climb back up the parse tree, validating open scopes. Mostly calls - * through to macro_end in macro.c. + * through to macro_end() in macro.c. */ int mdoc_endparse(struct mdoc *m) @@ -226,14 +222,12 @@ mdoc_endparse(struct mdoc *m) /* * Main parse routine. Parses a single line -- really just hands off to - * the macro or text parser. + * the macro (parsemacro()) or text parser (parsetext()). */ int mdoc_parseln(struct mdoc *m, int ln, char *buf) { - /* If in error-mode, then we parse no more. */ - if (MDOC_HALT & m->flags) return(0); @@ -242,22 +236,6 @@ mdoc_parseln(struct mdoc *m, int ln, char *buf) } -void -mdoc_vmsg(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...) -{ - char buf[256]; - va_list ap; - - if (NULL == mdoc->cb.mdoc_msg) - return; - - va_start(ap, fmt); - (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap); - va_end(ap); - (*mdoc->cb.mdoc_msg)(mdoc->data, ln, pos, buf); -} - - int mdoc_verr(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...) @@ -271,13 +249,13 @@ mdoc_verr(struct mdoc *mdoc, int ln, int pos, va_start(ap, fmt); (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap); va_end(ap); + return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf)); } int -mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, - enum mdoc_warn type, const char *fmt, ...) +mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...) { char buf[256]; va_list ap; @@ -288,38 +266,18 @@ mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, va_start(ap, fmt); (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap); va_end(ap); - return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, type, buf)); + + return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf)); } int -mdoc_macro(struct mdoc *m, int tok, - int ln, int pp, int *pos, char *buf) +mdoc_err(struct mdoc *m, int line, int pos, int iserr, enum merr type) { - - /* FIXME - these should happen during validation. */ - - if (MDOC_PROLOGUE & mdoc_macros[tok].flags && - SEC_PROLOGUE != m->lastnamed) - return(perr(m, ln, pp, EPROLBODY)); - - if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) && - SEC_PROLOGUE == m->lastnamed) - return(perr(m, ln, pp, EBODYPROL)); - - if (1 != pp && ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) - return(perr(m, ln, pp, ENOCALL)); - - return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf)); -} - - -static int -perr(struct mdoc *m, int line, int pos, enum merr type) -{ - char *p; - + char *p; + p = NULL; + switch (type) { case (ENOCALL): p = "not callable"; @@ -342,12 +300,183 @@ perr(struct mdoc *m, int line, int pos, enum merr type case (ESPACE): p = "whitespace disallowed after delimiter"; break; + case (ETOOLONG): + p = "text argument too long"; + break; + case (EESCAPE): + p = "invalid escape sequence"; + break; + case (EPRINT): + p = "invalid character"; + break; + case (ENESTDISP): + p = "displays may not be nested"; + break; + case (EBOOL): + p = "expected boolean value"; + break; + case (EARGREP): + p = "argument repeated"; + break; + case (EMULTIDISP): + p = "multiple display types specified"; + break; + case (EMULTILIST): + p = "multiple list types specified"; + break; + case (ELISTTYPE): + p = "missing list type"; + break; + case (EDISPTYPE): + p = "missing display type"; + break; + case (ESECNAME): + p = "the NAME section must come first"; + break; + case (ELINE): + p = "expected line arguments"; + break; + case (ENOPROLOGUE): + p = "document has no prologue"; + break; + case (ENODAT): + p = "document has no data"; + break; + case (ECOLMIS): + p = "column syntax style mismatch"; + break; + case (EATT): + p = "expected valid AT&T symbol"; + break; + case (ENAME): + p = "default name not yet set"; + break; + case (ENOWIDTH): + p = "superfluous width argument"; + break; + case (EMISSWIDTH): + p = "missing width argument"; + break; + case (EWRONGMSEC): + p = "document section in wrong manual section"; + break; + case (ESECOOO): + p = "document section out of conventional order"; + break; + case (ESECREP): + p = "document section repeated"; + break; + case (EBADSTAND): + p = "unknown standard"; + break; + case (ENAMESECINC): + p = "NAME section contents incomplete/badly-ordered"; + break; + case (ENOMULTILINE): + p = "suggested no multi-line arguments"; + break; + case (EMULTILINE): + p = "suggested multi-line arguments"; + break; + case (ENOLINE): + p = "suggested no line arguments"; + break; + case (EPROLOOO): + p = "prologue macros out-of-order"; + break; + case (EPROLREP): + p = "prologue macros repeated"; + break; + case (EARGVAL): + p = "argument value suggested"; + break; + case (EFONT): + p = "invalid font mode"; + break; + case (EBADMSEC): + p = "inappropriate manual section"; + break; + case (EBADSEC): + p = "inappropriate document section"; + break; + case (EQUOTTERM): + p = "unterminated quoted parameter"; + break; + case (EQUOTPARM): + p = "unexpected quoted parameter"; + break; + case (EARGVPARM): + p = "argument-like parameter"; + break; + case (ECOLEMPTY): + p = "last list column is empty"; + break; + case (ETAILWS): + p = "trailing whitespace"; + break; + case (ENUMFMT): + p = "bad number format"; + break; + case (EUTSNAME): + p = "utsname"; + break; + case (EBADDATE): + p = "malformed date syntax"; + break; + case (EOPEN): + p = "explicit scope still open on exit"; + break; + case (EQUOT): + p = "unterminated quotation"; + break; + case (ENOCTX): + p = "closure has no prior context"; + break; + case (ENOPARMS): + p = "unexpect line arguments"; + break; + case (EIGNE): + p = "ignoring empty element"; + break; + case (EIMPBRK): + p = "crufty end-of-line scope violation"; + break; + case (EMACPARM): + p = "macro-like parameter"; + break; + case (EOBS): + p = "macro marked obsolete"; + break; } + assert(p); - return(mdoc_perr(m, line, pos, p)); + + if (iserr) + return(mdoc_verr(m, line, pos, p)); + + return(mdoc_vwarn(m, line, pos, p)); } +int +mdoc_macro(struct mdoc *m, int tok, + int ln, int pp, int *pos, char *buf) +{ + + if (MDOC_PROLOGUE & mdoc_macros[tok].flags && + MDOC_PBODY & m->flags) + return(mdoc_perr(m, ln, pp, EPROLBODY)); + if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) && + ! (MDOC_PBODY & m->flags)) + return(mdoc_perr(m, ln, pp, EBODYPROL)); + + if (1 != pp && ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) + return(mdoc_perr(m, ln, pp, ENOCALL)); + + return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf)); +} + + static int node_append(struct mdoc *mdoc, struct mdoc_node *p) { @@ -371,6 +500,8 @@ node_append(struct mdoc *mdoc, struct mdoc_node *p) /* NOTREACHED */ } + p->parent->nchild++; + if ( ! mdoc_valid_pre(mdoc, p)) return(0); if ( ! mdoc_action_pre(mdoc, p)) @@ -417,7 +548,7 @@ node_alloc(struct mdoc *mdoc, int line, struct mdoc_node *p; if (NULL == (p = calloc(1, sizeof(struct mdoc_node)))) { - (void)verr(mdoc, EMALLOC); + (void)mdoc_nerr(mdoc, mdoc->last, EMALLOC); return(NULL); } @@ -480,7 +611,8 @@ mdoc_block_alloc(struct mdoc *mdoc, int line, int pos, p = node_alloc(mdoc, line, pos, tok, MDOC_BLOCK); if (NULL == p) return(0); - if ((p->args = args)) + p->args = args; + if (p->args) (args->refcnt)++; return(node_append(mdoc, p)); } @@ -495,7 +627,8 @@ mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos, p = node_alloc(mdoc, line, pos, tok, MDOC_ELEM); if (NULL == p) return(0); - if ((p->args = args)) + p->args = args; + if (p->args) (args->refcnt)++; return(node_append(mdoc, p)); } @@ -511,9 +644,10 @@ mdoc_word_alloc(struct mdoc *mdoc, if (NULL == p) return(0); if (NULL == (p->string = strdup(word))) { - (void)verr(mdoc, EMALLOC); + (void)mdoc_nerr(mdoc, mdoc->last, EMALLOC); return(0); } + return(node_append(mdoc, p)); } @@ -522,6 +656,8 @@ void mdoc_node_free(struct mdoc_node *p) { + if (p->parent) + p->parent->nchild--; if (p->string) free(p->string); if (p->args) @@ -539,6 +675,7 @@ mdoc_node_freelist(struct mdoc_node *p) if (p->next) mdoc_node_freelist(p->next); + assert(0 == p->nchild); mdoc_node_free(p); } @@ -551,11 +688,11 @@ static int parsetext(struct mdoc *m, int line, char *buf) { - if (SEC_PROLOGUE == m->lastnamed) - return(perr(m, line, 0, ETEXTPROL)); + if (SEC_NONE == m->lastnamed) + return(mdoc_perr(m, line, 0, ETEXTPROL)); if (0 == buf[0] && ! (MDOC_LITERAL & m->flags)) - return(perr(m, line, 0, ENOBLANK)); + return(mdoc_perr(m, line, 0, ENOBLANK)); if ( ! mdoc_word_alloc(m, line, 0, buf)) return(0); @@ -569,16 +706,14 @@ static int macrowarn(struct mdoc *m, int ln, const char *buf) { if ( ! (MDOC_IGN_MACRO & m->pflags)) - return(mdoc_perr(m, ln, 1, + return(mdoc_verr(m, ln, 1, "unknown macro: %s%s", buf, strlen(buf) > 3 ? "..." : "")); - return(mdoc_pwarn(m, ln, 1, WARN_SYNTAX, - "unknown macro: %s%s", + return(mdoc_vwarn(m, ln, 1, "unknown macro: %s%s", buf, strlen(buf) > 3 ? "..." : "")); } - /* * Parse a macro line, that is, a line beginning with the control * character. @@ -589,7 +724,7 @@ parsemacro(struct mdoc *m, int ln, char *buf) int i, c; char mac[5]; - /* Comments and empties are quickly ignored. */ + /* Empty lines are ignored. */ if (0 == buf[1]) return(1); @@ -600,12 +735,8 @@ parsemacro(struct mdoc *m, int ln, char *buf) i++; if (0 == buf[i]) return(1); - return(perr(m, ln, 1, ESPACE)); + return(mdoc_perr(m, ln, 1, ESPACE)); } - - if (buf[1] && '\\' == buf[1]) - if (buf[2] && '\"' == buf[2]) - return(1); /* Copy the first word into a nil-terminated buffer. */