=================================================================== RCS file: /cvs/mandoc/mdoc_argv.c,v retrieving revision 1.1 retrieving revision 1.90 diff -u -p -r1.1 -r1.90 --- mandoc/mdoc_argv.c 2009/03/27 15:00:15 1.1 +++ mandoc/mdoc_argv.c 2014/03/23 11:25:26 1.90 @@ -1,87 +1,73 @@ -/* $Id: mdoc_argv.c,v 1.1 2009/03/27 15:00:15 kristaps Exp $ */ +/* $Id: mdoc_argv.c,v 1.90 2014/03/23 11:25:26 schwarze Exp $ */ /* - * Copyright (c) 2008, 2009 Kristaps Dzonsons + * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons + * Copyright (c) 2012 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any - * purpose with or without fee is hereby granted, provided that the - * above copyright notice and this permission notice appear in all - * copies. + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL - * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE - * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL - * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR - * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER - * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR - * PERFORMANCE OF THIS SOFTWARE. + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + #include #include -#include -#include #include #include #include +#include "mdoc.h" +#include "mandoc.h" +#include "mandoc_aux.h" #include "libmdoc.h" +#include "libmandoc.h" -/* - * Routines to parse arguments of macros. Arguments follow the syntax - * of `-arg [val [valN...]]'. Arguments come in all types: quoted - * arguments, multiple arguments per value, no-value arguments, etc. - * - * There's no limit to the number or arguments that may be allocated. - */ +#define MULTI_STEP 5 /* pre-allocate argument values */ +#define DELIMSZ 6 /* max possible size of a delimiter */ -#define ARGS_QUOTED (1 << 0) -#define ARGS_DELIM (1 << 1) -#define ARGS_TABSEP (1 << 2) -#define ARGS_ARGVLIKE (1 << 3) +enum argsflag { + ARGSFL_NONE = 0, + ARGSFL_DELIM, /* handle delimiters of [[::delim::][ ]+]+ */ + ARGSFL_TABSEP /* handle tab/`Ta' separated phrases */ +}; -#define ARGV_NONE (1 << 0) -#define ARGV_SINGLE (1 << 1) -#define ARGV_MULTI (1 << 2) -#define ARGV_OPT_SINGLE (1 << 3) - -#define MULTI_STEP 5 - -enum mwarn { - WQUOTPARM, - WARGVPARM, - WCOLEMPTY, - WTAILWS +enum argvflag { + ARGV_NONE, /* no args to flag (e.g., -split) */ + ARGV_SINGLE, /* one arg to flag (e.g., -file xxx) */ + ARGV_MULTI /* multiple args (e.g., -column xxx yyy) */ }; -enum merr { - EQUOTTERM, - EARGVAL +struct mdocarg { + enum argsflag flags; + const enum mdocargt *argvs; }; -static int argv_a2arg(int, const char *); -static int args(struct mdoc *, int, int *, - char *, int, char **); -static int argv(struct mdoc *, int, +static void argn_free(struct mdoc_arg *, int); +static enum margserr args(struct mdoc *, int, int *, + char *, enum argsflag, char **); +static int args_checkpunct(const char *, int); +static int argv_multi(struct mdoc *, int, struct mdoc_argv *, int *, char *); static int argv_single(struct mdoc *, int, struct mdoc_argv *, int *, char *); -static int argv_opt_single(struct mdoc *, int, - struct mdoc_argv *, int *, char *); -static int argv_multi(struct mdoc *, int, - struct mdoc_argv *, int *, char *); -static int pwarn(struct mdoc *, int, int, enum mwarn); -static int perr(struct mdoc *, int, int, enum merr); -/* Per-argument flags. */ - -static int mdoc_argvflags[MDOC_ARG_MAX] = { +static const enum argvflag argvflags[MDOC_ARG_MAX] = { ARGV_NONE, /* MDOC_Split */ ARGV_NONE, /* MDOC_Nosplit */ ARGV_NONE, /* MDOC_Ragged */ ARGV_NONE, /* MDOC_Unfilled */ ARGV_NONE, /* MDOC_Literal */ - ARGV_NONE, /* MDOC_File */ + ARGV_SINGLE, /* MDOC_File */ ARGV_SINGLE, /* MDOC_Offset */ ARGV_NONE, /* MDOC_Bullet */ ARGV_NONE, /* MDOC_Dash */ @@ -96,7 +82,7 @@ static int mdoc_argvflags[MDOC_ARG_MAX] = { ARGV_MULTI, /* MDOC_Column */ ARGV_SINGLE, /* MDOC_Width */ ARGV_NONE, /* MDOC_Compact */ - ARGV_OPT_SINGLE, /* MDOC_Std */ + ARGV_NONE, /* MDOC_Std */ ARGV_NONE, /* MDOC_Filled */ ARGV_NONE, /* MDOC_Words */ ARGV_NONE, /* MDOC_Emphasis */ @@ -104,216 +90,287 @@ static int mdoc_argvflags[MDOC_ARG_MAX] = { ARGV_NONE /* MDOC_Symbolic */ }; -static int mdoc_argflags[MDOC_MAX] = { - 0, /* \" */ - 0, /* Dd */ - 0, /* Dt */ - 0, /* Os */ - ARGS_QUOTED, /* Sh */ - ARGS_QUOTED, /* Ss */ - ARGS_DELIM, /* Pp */ - ARGS_DELIM, /* D1 */ - ARGS_DELIM | ARGS_QUOTED, /* Dl */ - 0, /* Bd */ - 0, /* Ed */ - 0, /* Bl */ - 0, /* El */ - 0, /* It */ - ARGS_DELIM, /* Ad */ - ARGS_DELIM, /* An */ - ARGS_DELIM | ARGS_QUOTED, /* Ar */ - ARGS_QUOTED, /* Cd */ - ARGS_DELIM, /* Cm */ - ARGS_DELIM, /* Dv */ - ARGS_DELIM, /* Er */ - ARGS_DELIM, /* Ev */ - 0, /* Ex */ - ARGS_DELIM | ARGS_QUOTED, /* Fa */ - 0, /* Fd */ - ARGS_DELIM, /* Fl */ - ARGS_DELIM | ARGS_QUOTED, /* Fn */ - ARGS_DELIM | ARGS_QUOTED, /* Ft */ - ARGS_DELIM, /* Ic */ - 0, /* In */ - ARGS_DELIM | ARGS_QUOTED, /* Li */ - ARGS_QUOTED, /* Nd */ - ARGS_DELIM, /* Nm */ - ARGS_DELIM, /* Op */ - 0, /* Ot */ - ARGS_DELIM, /* Pa */ - 0, /* Rv */ - ARGS_DELIM | ARGS_ARGVLIKE, /* St */ - ARGS_DELIM, /* Va */ - ARGS_DELIM, /* Vt */ - ARGS_DELIM, /* Xr */ - ARGS_QUOTED, /* %A */ - ARGS_QUOTED, /* %B */ - ARGS_QUOTED, /* %D */ - ARGS_QUOTED, /* %I */ - ARGS_QUOTED, /* %J */ - ARGS_QUOTED, /* %N */ - ARGS_QUOTED, /* %O */ - ARGS_QUOTED, /* %P */ - ARGS_QUOTED, /* %R */ - ARGS_QUOTED, /* %T */ - ARGS_QUOTED, /* %V */ - ARGS_DELIM, /* Ac */ - 0, /* Ao */ - ARGS_DELIM, /* Aq */ - ARGS_DELIM, /* At */ - ARGS_DELIM, /* Bc */ - 0, /* Bf */ - 0, /* Bo */ - ARGS_DELIM, /* Bq */ - ARGS_DELIM, /* Bsx */ - ARGS_DELIM, /* Bx */ - 0, /* Db */ - ARGS_DELIM, /* Dc */ - 0, /* Do */ - ARGS_DELIM, /* Dq */ - ARGS_DELIM, /* Ec */ - 0, /* Ef */ - ARGS_DELIM, /* Em */ - 0, /* Eo */ - ARGS_DELIM, /* Fx */ - ARGS_DELIM, /* Ms */ - ARGS_DELIM, /* No */ - ARGS_DELIM, /* Ns */ - ARGS_DELIM, /* Nx */ - ARGS_DELIM, /* Ox */ - ARGS_DELIM, /* Pc */ - ARGS_DELIM, /* Pf */ - 0, /* Po */ - ARGS_DELIM, /* Pq */ - ARGS_DELIM, /* Qc */ - ARGS_DELIM, /* Ql */ - 0, /* Qo */ - ARGS_DELIM, /* Qq */ - 0, /* Re */ - 0, /* Rs */ - ARGS_DELIM, /* Sc */ - 0, /* So */ - ARGS_DELIM, /* Sq */ - 0, /* Sm */ - ARGS_DELIM, /* Sx */ - ARGS_DELIM | ARGS_QUOTED, /* Sy */ - ARGS_DELIM, /* Tn */ - ARGS_DELIM, /* Ux */ - ARGS_DELIM, /* Xc */ - 0, /* Xo */ - ARGS_QUOTED, /* Fo */ - 0, /* Fc */ - 0, /* Oo */ - ARGS_DELIM, /* Oc */ - 0, /* Bk */ - 0, /* Ek */ - 0, /* Bt */ - 0, /* Hf */ - 0, /* Fr */ - 0, /* Ud */ - 0, /* Lb */ - 0, /* Ap */ - ARGS_DELIM, /* Lp */ - ARGS_DELIM | ARGS_QUOTED, /* Lk */ - ARGS_DELIM | ARGS_QUOTED, /* Mt */ - ARGS_DELIM, /* Brq */ - 0, /* Bro */ - ARGS_DELIM, /* Brc */ - ARGS_QUOTED, /* %C */ - 0, /* Es */ - 0, /* En */ - 0, /* Dx */ - ARGS_QUOTED, /* %Q */ +static const enum mdocargt args_Ex[] = { + MDOC_Std, + MDOC_ARG_MAX }; +static const enum mdocargt args_An[] = { + MDOC_Split, + MDOC_Nosplit, + MDOC_ARG_MAX +}; +static const enum mdocargt args_Bd[] = { + MDOC_Ragged, + MDOC_Unfilled, + MDOC_Filled, + MDOC_Literal, + MDOC_File, + MDOC_Offset, + MDOC_Compact, + MDOC_Centred, + MDOC_ARG_MAX +}; + +static const enum mdocargt args_Bf[] = { + MDOC_Emphasis, + MDOC_Literal, + MDOC_Symbolic, + MDOC_ARG_MAX +}; + +static const enum mdocargt args_Bk[] = { + MDOC_Words, + MDOC_ARG_MAX +}; + +static const enum mdocargt args_Bl[] = { + MDOC_Bullet, + MDOC_Dash, + MDOC_Hyphen, + MDOC_Item, + MDOC_Enum, + MDOC_Tag, + MDOC_Diag, + MDOC_Hang, + MDOC_Ohang, + MDOC_Inset, + MDOC_Column, + MDOC_Width, + MDOC_Offset, + MDOC_Compact, + MDOC_Nested, + MDOC_ARG_MAX +}; + +static const struct mdocarg mdocargs[MDOC_MAX] = { + { ARGSFL_DELIM, NULL }, /* Ap */ + { ARGSFL_NONE, NULL }, /* Dd */ + { ARGSFL_NONE, NULL }, /* Dt */ + { ARGSFL_NONE, NULL }, /* Os */ + { ARGSFL_NONE, NULL }, /* Sh */ + { ARGSFL_NONE, NULL }, /* Ss */ + { ARGSFL_NONE, NULL }, /* Pp */ + { ARGSFL_DELIM, NULL }, /* D1 */ + { ARGSFL_DELIM, NULL }, /* Dl */ + { ARGSFL_NONE, args_Bd }, /* Bd */ + { ARGSFL_NONE, NULL }, /* Ed */ + { ARGSFL_NONE, args_Bl }, /* Bl */ + { ARGSFL_NONE, NULL }, /* El */ + { ARGSFL_NONE, NULL }, /* It */ + { ARGSFL_DELIM, NULL }, /* Ad */ + { ARGSFL_DELIM, args_An }, /* An */ + { ARGSFL_DELIM, NULL }, /* Ar */ + { ARGSFL_DELIM, NULL }, /* Cd */ + { ARGSFL_DELIM, NULL }, /* Cm */ + { ARGSFL_DELIM, NULL }, /* Dv */ + { ARGSFL_DELIM, NULL }, /* Er */ + { ARGSFL_DELIM, NULL }, /* Ev */ + { ARGSFL_NONE, args_Ex }, /* Ex */ + { ARGSFL_DELIM, NULL }, /* Fa */ + { ARGSFL_NONE, NULL }, /* Fd */ + { ARGSFL_DELIM, NULL }, /* Fl */ + { ARGSFL_DELIM, NULL }, /* Fn */ + { ARGSFL_DELIM, NULL }, /* Ft */ + { ARGSFL_DELIM, NULL }, /* Ic */ + { ARGSFL_DELIM, NULL }, /* In */ + { ARGSFL_DELIM, NULL }, /* Li */ + { ARGSFL_NONE, NULL }, /* Nd */ + { ARGSFL_DELIM, NULL }, /* Nm */ + { ARGSFL_DELIM, NULL }, /* Op */ + { ARGSFL_NONE, NULL }, /* Ot */ + { ARGSFL_DELIM, NULL }, /* Pa */ + { ARGSFL_NONE, args_Ex }, /* Rv */ + { ARGSFL_DELIM, NULL }, /* St */ + { ARGSFL_DELIM, NULL }, /* Va */ + { ARGSFL_DELIM, NULL }, /* Vt */ + { ARGSFL_DELIM, NULL }, /* Xr */ + { ARGSFL_NONE, NULL }, /* %A */ + { ARGSFL_NONE, NULL }, /* %B */ + { ARGSFL_NONE, NULL }, /* %D */ + { ARGSFL_NONE, NULL }, /* %I */ + { ARGSFL_NONE, NULL }, /* %J */ + { ARGSFL_NONE, NULL }, /* %N */ + { ARGSFL_NONE, NULL }, /* %O */ + { ARGSFL_NONE, NULL }, /* %P */ + { ARGSFL_NONE, NULL }, /* %R */ + { ARGSFL_NONE, NULL }, /* %T */ + { ARGSFL_NONE, NULL }, /* %V */ + { ARGSFL_DELIM, NULL }, /* Ac */ + { ARGSFL_NONE, NULL }, /* Ao */ + { ARGSFL_DELIM, NULL }, /* Aq */ + { ARGSFL_DELIM, NULL }, /* At */ + { ARGSFL_DELIM, NULL }, /* Bc */ + { ARGSFL_NONE, args_Bf }, /* Bf */ + { ARGSFL_NONE, NULL }, /* Bo */ + { ARGSFL_DELIM, NULL }, /* Bq */ + { ARGSFL_DELIM, NULL }, /* Bsx */ + { ARGSFL_DELIM, NULL }, /* Bx */ + { ARGSFL_NONE, NULL }, /* Db */ + { ARGSFL_DELIM, NULL }, /* Dc */ + { ARGSFL_NONE, NULL }, /* Do */ + { ARGSFL_DELIM, NULL }, /* Dq */ + { ARGSFL_DELIM, NULL }, /* Ec */ + { ARGSFL_NONE, NULL }, /* Ef */ + { ARGSFL_DELIM, NULL }, /* Em */ + { ARGSFL_NONE, NULL }, /* Eo */ + { ARGSFL_DELIM, NULL }, /* Fx */ + { ARGSFL_DELIM, NULL }, /* Ms */ + { ARGSFL_DELIM, NULL }, /* No */ + { ARGSFL_DELIM, NULL }, /* Ns */ + { ARGSFL_DELIM, NULL }, /* Nx */ + { ARGSFL_DELIM, NULL }, /* Ox */ + { ARGSFL_DELIM, NULL }, /* Pc */ + { ARGSFL_DELIM, NULL }, /* Pf */ + { ARGSFL_NONE, NULL }, /* Po */ + { ARGSFL_DELIM, NULL }, /* Pq */ + { ARGSFL_DELIM, NULL }, /* Qc */ + { ARGSFL_DELIM, NULL }, /* Ql */ + { ARGSFL_NONE, NULL }, /* Qo */ + { ARGSFL_DELIM, NULL }, /* Qq */ + { ARGSFL_NONE, NULL }, /* Re */ + { ARGSFL_NONE, NULL }, /* Rs */ + { ARGSFL_DELIM, NULL }, /* Sc */ + { ARGSFL_NONE, NULL }, /* So */ + { ARGSFL_DELIM, NULL }, /* Sq */ + { ARGSFL_NONE, NULL }, /* Sm */ + { ARGSFL_DELIM, NULL }, /* Sx */ + { ARGSFL_DELIM, NULL }, /* Sy */ + { ARGSFL_DELIM, NULL }, /* Tn */ + { ARGSFL_DELIM, NULL }, /* Ux */ + { ARGSFL_DELIM, NULL }, /* Xc */ + { ARGSFL_NONE, NULL }, /* Xo */ + { ARGSFL_NONE, NULL }, /* Fo */ + { ARGSFL_DELIM, NULL }, /* Fc */ + { ARGSFL_NONE, NULL }, /* Oo */ + { ARGSFL_DELIM, NULL }, /* Oc */ + { ARGSFL_NONE, args_Bk }, /* Bk */ + { ARGSFL_NONE, NULL }, /* Ek */ + { ARGSFL_NONE, NULL }, /* Bt */ + { ARGSFL_NONE, NULL }, /* Hf */ + { ARGSFL_NONE, NULL }, /* Fr */ + { ARGSFL_NONE, NULL }, /* Ud */ + { ARGSFL_DELIM, NULL }, /* Lb */ + { ARGSFL_NONE, NULL }, /* Lp */ + { ARGSFL_DELIM, NULL }, /* Lk */ + { ARGSFL_DELIM, NULL }, /* Mt */ + { ARGSFL_DELIM, NULL }, /* Brq */ + { ARGSFL_NONE, NULL }, /* Bro */ + { ARGSFL_DELIM, NULL }, /* Brc */ + { ARGSFL_NONE, NULL }, /* %C */ + { ARGSFL_NONE, NULL }, /* Es */ + { ARGSFL_NONE, NULL }, /* En */ + { ARGSFL_DELIM, NULL }, /* Dx */ + { ARGSFL_NONE, NULL }, /* %Q */ + { ARGSFL_NONE, NULL }, /* br */ + { ARGSFL_NONE, NULL }, /* sp */ + { ARGSFL_NONE, NULL }, /* %U */ + { ARGSFL_NONE, NULL }, /* Ta */ +}; + + /* * Parse an argument from line text. This comes in the form of -key * [value0...], which may either have a single mandatory value, at least * one mandatory value, an optional single value, or no value. */ -int -mdoc_argv(struct mdoc *mdoc, int line, int tok, +enum margverr +mdoc_argv(struct mdoc *mdoc, int line, enum mdoct tok, struct mdoc_arg **v, int *pos, char *buf) { - int i; char *p, sv; struct mdoc_argv tmp; struct mdoc_arg *arg; + const enum mdocargt *ap; - if (0 == buf[*pos]) + if ('\0' == buf[*pos]) return(ARGV_EOLN); - - assert(' ' != buf[*pos]); - - if ('-' != buf[*pos] || ARGS_ARGVLIKE & mdoc_argflags[tok]) + else if (NULL == (ap = mdocargs[tok].argvs)) return(ARGV_WORD); + else if ('-' != buf[*pos]) + return(ARGV_WORD); - /* Parse through to the first unescaped space. */ + /* Seek to the first unescaped space. */ - i = *pos; p = &buf[++(*pos)]; assert(*pos > 0); - /* LINTED */ - while (buf[*pos]) { - if (' ' == buf[*pos]) - if ('\\' != buf[*pos - 1]) - break; - (*pos)++; - } + for ( ; buf[*pos] ; (*pos)++) + if (' ' == buf[*pos] && '\\' != buf[*pos - 1]) + break; - /* XXX - save zeroed byte, if not an argument. */ + /* + * We want to nil-terminate the word to look it up (it's easier + * that way). But we may not have a flag, in which case we need + * to restore the line as-is. So keep around the stray byte, + * which we'll reset upon exiting (if necessary). + */ - sv = 0; - if (buf[*pos]) { - sv = buf[*pos]; - buf[(*pos)++] = 0; - } + if ('\0' != (sv = buf[*pos])) + buf[(*pos)++] = '\0'; - (void)memset(&tmp, 0, sizeof(struct mdoc_argv)); + /* + * Now look up the word as a flag. Use temporary storage that + * we'll copy into the node's flags, if necessary. + */ + + memset(&tmp, 0, sizeof(struct mdoc_argv)); + tmp.line = line; tmp.pos = *pos; + tmp.arg = MDOC_ARG_MAX; - /* See if our token accepts the argument. */ + while (MDOC_ARG_MAX != (tmp.arg = *ap++)) + if (0 == strcmp(p, mdoc_argnames[tmp.arg])) + break; - if (MDOC_ARG_MAX == (tmp.arg = argv_a2arg(tok, p))) { - /* XXX - restore saved zeroed byte. */ + if (MDOC_ARG_MAX == tmp.arg) { + /* + * The flag was not found. + * Restore saved zeroed byte and return as a word. + */ if (sv) buf[*pos - 1] = sv; - if ( ! pwarn(mdoc, line, i, WARGVPARM)) - return(ARGV_ERROR); return(ARGV_WORD); } + /* Read to the next word (the argument). */ + while (buf[*pos] && ' ' == buf[*pos]) (*pos)++; - if ( ! argv(mdoc, line, &tmp, pos, buf)) - return(ARGV_ERROR); + switch (argvflags[tmp.arg]) { + case (ARGV_SINGLE): + if ( ! argv_single(mdoc, line, &tmp, pos, buf)) + return(ARGV_ERROR); + break; + case (ARGV_MULTI): + if ( ! argv_multi(mdoc, line, &tmp, pos, buf)) + return(ARGV_ERROR); + break; + case (ARGV_NONE): + break; + } - if (NULL == (arg = *v)) { - if (NULL == (*v = calloc(1, sizeof(struct mdoc_arg)))) - err(1, "calloc"); - arg = *v; - } + if (NULL == (arg = *v)) + arg = *v = mandoc_calloc(1, sizeof(struct mdoc_arg)); arg->argc++; - arg->argv = xrealloc(arg->argv, arg->argc * - sizeof(struct mdoc_argv)); + arg->argv = mandoc_realloc + (arg->argv, arg->argc * sizeof(struct mdoc_argv)); - (void)memcpy(&arg->argv[(int)arg->argc - 1], + memcpy(&arg->argv[(int)arg->argc - 1], &tmp, sizeof(struct mdoc_argv)); return(ARGV_ARG); } - void mdoc_argv_free(struct mdoc_arg *p) { - int i, j; + int i; if (NULL == p) return; @@ -323,535 +380,317 @@ mdoc_argv_free(struct mdoc_arg *p) if (p->refcnt) return; } - assert(p->argc); - /* LINTED */ - for (i = 0; i < (int)p->argc; i++) { - if (0 == p->argv[i].sz) - continue; - /* LINTED */ - for (j = 0; j < (int)p->argv[i].sz; j++) - free(p->argv[i].value[j]); + for (i = (int)p->argc - 1; i >= 0; i--) + argn_free(p, i); - free(p->argv[i].value); - } - free(p->argv); free(p); } - - -static int -perr(struct mdoc *mdoc, int line, int pos, enum merr code) +static void +argn_free(struct mdoc_arg *p, int iarg) { - char *p; + struct mdoc_argv *arg; + int j; - p = NULL; + arg = &p->argv[iarg]; - switch (code) { - case (EQUOTTERM): - p = "unterminated quoted parameter"; - break; - case (EARGVAL): - p = "argument requires a value"; - break; + if (arg->sz && arg->value) { + for (j = (int)arg->sz - 1; j >= 0; j--) + free(arg->value[j]); + free(arg->value); } - assert(p); - return(mdoc_perr(mdoc, line, pos, p)); + for (--p->argc; iarg < (int)p->argc; iarg++) + p->argv[iarg] = p->argv[iarg+1]; } - -static int -pwarn(struct mdoc *mdoc, int line, int pos, enum mwarn code) +enum margserr +mdoc_zargs(struct mdoc *mdoc, int line, int *pos, char *buf, char **v) { - char *p; - int c; - p = NULL; - c = WARN_SYNTAX; - - switch (code) { - case (WQUOTPARM): - p = "unexpected quoted parameter"; - break; - case (WARGVPARM): - p = "argument-like parameter"; - break; - case (WCOLEMPTY): - p = "last list column is empty"; - c = WARN_COMPAT; - break; - case (WTAILWS): - p = "trailing whitespace"; - c = WARN_COMPAT; - break; - } - - assert(p); - return(mdoc_pwarn(mdoc, line, pos, c, p)); + return(args(mdoc, line, pos, buf, ARGSFL_NONE, v)); } - -int -mdoc_args(struct mdoc *mdoc, int line, - int *pos, char *buf, int tok, char **v) +enum margserr +mdoc_args(struct mdoc *mdoc, int line, int *pos, + char *buf, enum mdoct tok, char **v) { - int fl, c, i; + enum argsflag fl; struct mdoc_node *n; - fl = (0 == tok) ? 0 : mdoc_argflags[tok]; + fl = mdocargs[tok].flags; - /* - * Override per-macro argument flags with context-specific ones. - * As of now, this is only valid for `It' depending on its list - * context. + if (MDOC_It != tok) + return(args(mdoc, line, pos, buf, fl, v)); + + /* + * We know that we're in an `It', so it's reasonable to expect + * us to be sitting in a `Bl'. Someday this may not be the case + * (if we allow random `It's sitting out there), so provide a + * safe fall-back into the default behaviour. */ - switch (tok) { - case (MDOC_It): - for (n = mdoc->last; n; n = n->parent) - if (MDOC_BLOCK == n->type && MDOC_Bl == n->tok) + for (n = mdoc->last; n; n = n->parent) + if (MDOC_Bl == n->tok) + if (LIST_column == n->norm->Bl.type) { + fl = ARGSFL_TABSEP; break; - - assert(n); - c = (int)(n->args ? n->args->argc : 0); - assert(c > 0); - - /* - * Using `Bl -column' adds ARGS_TABSEP to the arguments - * and invalidates ARGS_DELIM. Using `Bl -diag' allows - * for quoted arguments. - */ - - /* LINTED */ - for (i = 0; i < c; i++) { - switch (n->args->argv[i].arg) { - case (MDOC_Column): - fl |= ARGS_TABSEP; - fl &= ~ARGS_DELIM; - i = c; - break; - case (MDOC_Diag): - fl |= ARGS_QUOTED; - i = c; - break; - default: - break; } - } - break; - default: - break; - } return(args(mdoc, line, pos, buf, fl, v)); } - -static int -args(struct mdoc *mdoc, int line, - int *pos, char *buf, int fl, char **v) +static enum margserr +args(struct mdoc *mdoc, int line, int *pos, + char *buf, enum argsflag fl, char **v) { - int i; - char *p, *pp; + char *p, *pp; + int pairs; + enum margserr rc; - assert(*pos > 0); + if ('\0' == buf[*pos]) { + if (MDOC_PPHRASE & mdoc->flags) + return(ARGS_EOLN); + /* + * If we're not in a partial phrase and the flag for + * being a phrase literal is still set, the punctuation + * is unterminated. + */ + if (MDOC_PHRASELIT & mdoc->flags) + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_BADQUOTE); - if (0 == buf[*pos]) + mdoc->flags &= ~MDOC_PHRASELIT; return(ARGS_EOLN); + } - if ('\"' == buf[*pos] && ! (fl & ARGS_QUOTED)) - if ( ! pwarn(mdoc, line, *pos, WQUOTPARM)) - return(ARGS_ERROR); + *v = &buf[*pos]; - if ( ! (fl & ARGS_ARGVLIKE) && '-' == buf[*pos]) - if ( ! pwarn(mdoc, line, *pos, WARGVPARM)) - return(ARGS_ERROR); + if (ARGSFL_DELIM == fl) + if (args_checkpunct(buf, *pos)) + return(ARGS_PUNCT); - /* - * If the first character is a delimiter and we're to look for - * delimited strings, then pass down the buffer seeing if it - * follows the pattern of [[::delim::][ ]+]+. + /* + * First handle TABSEP items, restricted to `Bl -column'. This + * ignores conventional token parsing and instead uses tabs or + * `Ta' macros to separate phrases. Phrases are parsed again + * for arguments at a later phase. */ - if ((fl & ARGS_DELIM) && mdoc_iscdelim(buf[*pos])) { - for (i = *pos; buf[i]; ) { - if ( ! mdoc_iscdelim(buf[i])) - break; - i++; - /* There must be at least one space... */ - if (0 == buf[i] || ' ' != buf[i]) - break; - i++; - while (buf[i] && ' ' == buf[i]) - i++; - } - if (0 == buf[i]) { - *v = &buf[*pos]; - return(ARGS_PUNCT); - } - } + if (ARGSFL_TABSEP == fl) { + /* Scan ahead to tab (can't be escaped). */ + p = strchr(*v, '\t'); + pp = NULL; - /* First parse non-quoted strings. */ - - if ('\"' != buf[*pos] || ! (ARGS_QUOTED & fl)) { - *v = &buf[*pos]; - - /* - * Thar be dragons here! If we're tab-separated, search - * ahead for either a tab or the `Ta' macro. - * If a `Ta' is detected, it must be space-buffered before and - * after. If either of these hold true, then prune out the - * extra spaces and call it an argument. - */ - - if (ARGS_TABSEP & fl) { - /* Scan ahead to unescaped tab. */ - - p = strchr(*v, '\t'); - - /* Scan ahead to unescaped `Ta'. */ - + /* Scan ahead to unescaped `Ta'. */ + if ( ! (MDOC_PHRASELIT & mdoc->flags)) for (pp = *v; ; pp++) { if (NULL == (pp = strstr(pp, "Ta"))) break; if (pp > *v && ' ' != *(pp - 1)) continue; - if (' ' == *(pp + 2) || 0 == *(pp + 2)) + if (' ' == *(pp + 2) || '\0' == *(pp + 2)) break; } - /* Choose delimiter tab/Ta. */ + /* By default, assume a phrase. */ + rc = ARGS_PHRASE; - if (p && pp) - p = (p < pp ? p : pp); - else if ( ! p && pp) - p = pp; - - /* Strip delimiter's preceding whitespace. */ - - if (p && p > *v) { - pp = p - 1; - while (pp > *v && ' ' == *pp) - pp--; - if (pp == *v && ' ' == *pp) - *pp = 0; - else if (' ' == *pp) - *(pp + 1) = 0; - } - - /* ...in- and proceding whitespace. */ - - if (p && ('\t' != *p)) { - *p++ = 0; - *p++ = 0; - } else if (p) - *p++ = 0; - - if (p) { - while (' ' == *p) - p++; - if (0 != *p) - *(p - 1) = 0; - *pos += (int)(p - *v); - } - - if (p && 0 == *p) - if ( ! pwarn(mdoc, line, *pos, WCOLEMPTY)) - return(0); - if (p && 0 == *p && p > *v && ' ' == *(p - 1)) - if ( ! pwarn(mdoc, line, *pos, WTAILWS)) - return(0); - - if (p) - return(ARGS_PHRASE); - - /* Configure the eoln case, too. */ - + /* + * Adjust new-buffer position to be beyond delimiter + * mark (e.g., Ta -> end + 2). + */ + if (p && pp) { + *pos += pp < p ? 2 : 1; + rc = pp < p ? ARGS_PHRASE : ARGS_PPHRASE; + p = pp < p ? pp : p; + } else if (p && ! pp) { + rc = ARGS_PPHRASE; + *pos += 1; + } else if (pp && ! p) { + p = pp; + *pos += 2; + } else { + rc = ARGS_PEND; p = strchr(*v, 0); - assert(p); + } - if (p > *v && ' ' == *(p - 1)) - if ( ! pwarn(mdoc, line, *pos, WTAILWS)) - return(0); - *pos += (int)(p - *v); + /* Whitespace check for eoln case... */ + if ('\0' == *p && ' ' == *(p - 1)) + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_EOLNSPACE); - return(ARGS_PHRASE); - } - - /* Do non-tabsep look-ahead here. */ - - if ( ! (ARGS_TABSEP & fl)) - while (buf[*pos]) { - if (' ' == buf[*pos]) - if ('\\' != buf[*pos - 1]) - break; - (*pos)++; - } + *pos += (int)(p - *v); - if (0 == buf[*pos]) - return(ARGS_WORD); + /* Strip delimiter's preceding whitespace. */ + pp = p - 1; + while (pp > *v && ' ' == *pp) { + if (pp > *v && '\\' == *(pp - 1)) + break; + pp--; + } + *(pp + 1) = 0; - buf[(*pos)++] = 0; + /* Strip delimiter's proceeding whitespace. */ + for (pp = &buf[*pos]; ' ' == *pp; pp++, (*pos)++) + /* Skip ahead. */ ; - if (0 == buf[*pos]) - return(ARGS_WORD); - - if ( ! (ARGS_TABSEP & fl)) - while (buf[*pos] && ' ' == buf[*pos]) - (*pos)++; - - if (buf[*pos]) - return(ARGS_WORD); - - if ( ! pwarn(mdoc, line, *pos, WTAILWS)) - return(ARGS_ERROR); - - return(ARGS_WORD); + return(rc); } /* - * If we're a quoted string (and quoted strings are allowed), - * then parse ahead to the next quote. If none's found, it's an - * error. After, parse to the next word. + * Process a quoted literal. A quote begins with a double-quote + * and ends with a double-quote NOT preceded by a double-quote. + * NUL-terminate the literal in place. + * Collapse pairs of quotes inside quoted literals. + * Whitespace is NOT involved in literal termination. */ - *v = &buf[++(*pos)]; + if (MDOC_PHRASELIT & mdoc->flags || '\"' == buf[*pos]) { + if ( ! (MDOC_PHRASELIT & mdoc->flags)) + *v = &buf[++(*pos)]; - while (buf[*pos] && '\"' != buf[*pos]) - (*pos)++; + if (MDOC_PPHRASE & mdoc->flags) + mdoc->flags |= MDOC_PHRASELIT; - if (0 == buf[*pos]) { - (void)perr(mdoc, line, *pos, EQUOTTERM); - return(ARGS_ERROR); - } + pairs = 0; + for ( ; buf[*pos]; (*pos)++) { + /* Move following text left after quoted quotes. */ + if (pairs) + buf[*pos - pairs] = buf[*pos]; + if ('\"' != buf[*pos]) + continue; + /* Unquoted quotes end quoted args. */ + if ('\"' != buf[*pos + 1]) + break; + /* Quoted quotes collapse. */ + pairs++; + (*pos)++; + } + if (pairs) + buf[*pos - pairs] = '\0'; - buf[(*pos)++] = 0; - if (0 == buf[*pos]) - return(ARGS_QWORD); + if ('\0' == buf[*pos]) { + if (MDOC_PPHRASE & mdoc->flags) + return(ARGS_QWORD); + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_BADQUOTE); + return(ARGS_QWORD); + } - while (buf[*pos] && ' ' == buf[*pos]) - (*pos)++; + mdoc->flags &= ~MDOC_PHRASELIT; + buf[(*pos)++] = '\0'; - if (buf[*pos]) + if ('\0' == buf[*pos]) + return(ARGS_QWORD); + + while (' ' == buf[*pos]) + (*pos)++; + + if ('\0' == buf[*pos]) + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_EOLNSPACE); + return(ARGS_QWORD); + } - if ( ! pwarn(mdoc, line, *pos, WTAILWS)) - return(ARGS_ERROR); + p = &buf[*pos]; + *v = mandoc_getarg(mdoc->parse, &p, line, pos); - return(ARGS_QWORD); + return(ARGS_WORD); } - +/* + * Check if the string consists only of space-separated closing + * delimiters. This is a bit of a dance: the first must be a close + * delimiter, but it may be followed by middle delimiters. Arbitrary + * whitespace may separate these tokens. + */ static int -argv_a2arg(int tok, const char *argv) +args_checkpunct(const char *buf, int i) { + int j; + char dbuf[DELIMSZ]; + enum mdelim d; - /* - * Parse an argument identifier from its text. XXX - this - * should really be table-driven to clarify the code. - * - * If you add an argument to the list, make sure that you - * register it here with its one or more macros! - */ + /* First token must be a close-delimiter. */ - switch (tok) { - case (MDOC_An): - if (xstrcmp(argv, "split")) - return(MDOC_Split); - else if (xstrcmp(argv, "nosplit")) - return(MDOC_Nosplit); - break; + for (j = 0; buf[i] && ' ' != buf[i] && j < DELIMSZ; j++, i++) + dbuf[j] = buf[i]; - case (MDOC_Bd): - if (xstrcmp(argv, "ragged")) - return(MDOC_Ragged); - else if (xstrcmp(argv, "unfilled")) - return(MDOC_Unfilled); - else if (xstrcmp(argv, "filled")) - return(MDOC_Filled); - else if (xstrcmp(argv, "literal")) - return(MDOC_Literal); - else if (xstrcmp(argv, "file")) - return(MDOC_File); - else if (xstrcmp(argv, "offset")) - return(MDOC_Offset); - else if (xstrcmp(argv, "compact")) - return(MDOC_Compact); - break; + if (DELIMSZ == j) + return(0); - case (MDOC_Bf): - if (xstrcmp(argv, "emphasis")) - return(MDOC_Emphasis); - else if (xstrcmp(argv, "literal")) - return(MDOC_Literal); - else if (xstrcmp(argv, "symbolic")) - return(MDOC_Symbolic); - break; + dbuf[j] = '\0'; + if (DELIM_CLOSE != mdoc_isdelim(dbuf)) + return(0); - case (MDOC_Bk): - if (xstrcmp(argv, "words")) - return(MDOC_Words); - break; + while (' ' == buf[i]) + i++; - case (MDOC_Bl): - if (xstrcmp(argv, "bullet")) - return(MDOC_Bullet); - else if (xstrcmp(argv, "dash")) - return(MDOC_Dash); - else if (xstrcmp(argv, "hyphen")) - return(MDOC_Hyphen); - else if (xstrcmp(argv, "item")) - return(MDOC_Item); - else if (xstrcmp(argv, "enum")) - return(MDOC_Enum); - else if (xstrcmp(argv, "tag")) - return(MDOC_Tag); - else if (xstrcmp(argv, "diag")) - return(MDOC_Diag); - else if (xstrcmp(argv, "hang")) - return(MDOC_Hang); - else if (xstrcmp(argv, "ohang")) - return(MDOC_Ohang); - else if (xstrcmp(argv, "inset")) - return(MDOC_Inset); - else if (xstrcmp(argv, "column")) - return(MDOC_Column); - else if (xstrcmp(argv, "width")) - return(MDOC_Width); - else if (xstrcmp(argv, "offset")) - return(MDOC_Offset); - else if (xstrcmp(argv, "compact")) - return(MDOC_Compact); - else if (xstrcmp(argv, "nested")) - return(MDOC_Nested); - break; + /* Remaining must NOT be open/none. */ - case (MDOC_Rv): - /* FALLTHROUGH */ - case (MDOC_Ex): - if (xstrcmp(argv, "std")) - return(MDOC_Std); - break; - default: - break; + while (buf[i]) { + j = 0; + while (buf[i] && ' ' != buf[i] && j < DELIMSZ) + dbuf[j++] = buf[i++]; + + if (DELIMSZ == j) + return(0); + + dbuf[j] = '\0'; + d = mdoc_isdelim(dbuf); + if (DELIM_NONE == d || DELIM_OPEN == d) + return(0); + + while (' ' == buf[i]) + i++; } - return(MDOC_ARG_MAX); + return('\0' == buf[i]); } - static int argv_multi(struct mdoc *mdoc, int line, struct mdoc_argv *v, int *pos, char *buf) { - int c, ppos; + enum margserr ac; char *p; - ppos = *pos; - for (v->sz = 0; ; v->sz++) { if ('-' == buf[*pos]) break; - c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); - if (ARGS_ERROR == c) + ac = args(mdoc, line, pos, buf, ARGSFL_NONE, &p); + if (ARGS_ERROR == ac) return(0); - else if (ARGS_EOLN == c) + else if (ARGS_EOLN == ac) break; if (0 == v->sz % MULTI_STEP) - v->value = xrealloc(v->value, + v->value = mandoc_realloc(v->value, (v->sz + MULTI_STEP) * sizeof(char *)); - if (NULL == (v->value[(int)v->sz] = strdup(p))) - err(1, "strdup"); + + v->value[(int)v->sz] = mandoc_strdup(p); } - if (v->sz) - return(1); - - return(perr(mdoc, line, ppos, EARGVAL)); -} - - -static int -argv_opt_single(struct mdoc *mdoc, int line, - struct mdoc_argv *v, int *pos, char *buf) -{ - int c; - char *p; - - if ('-' == buf[*pos]) - return(1); - - c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); - if (ARGS_ERROR == c) - return(0); - if (ARGS_EOLN == c) - return(1); - - v->sz = 1; - if (NULL == (v->value = calloc(1, sizeof(char *)))) - err(1, "calloc"); - if (NULL == (v->value[0] = strdup(p))) - err(1, "strdup"); return(1); } - -/* - * Parse a single, mandatory value from the stream. - */ static int argv_single(struct mdoc *mdoc, int line, struct mdoc_argv *v, int *pos, char *buf) { - int c, ppos; + enum margserr ac; char *p; - ppos = *pos; - - c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); - if (ARGS_ERROR == c) + ac = args(mdoc, line, pos, buf, ARGSFL_NONE, &p); + if (ARGS_ERROR == ac) return(0); - if (ARGS_EOLN == c) - return(perr(mdoc, line, ppos, EARGVAL)); + if (ARGS_EOLN == ac) + return(1); v->sz = 1; - if (NULL == (v->value = calloc(1, sizeof(char *)))) - err(1, "calloc"); - if (NULL == (v->value[0] = strdup(p))) - err(1, "strdup"); - return(1); -} - - -/* - * Determine rules for parsing arguments. Arguments can either accept - * no parameters, an optional single parameter, one parameter, or - * multiple parameters. - */ -static int -argv(struct mdoc *mdoc, int line, - struct mdoc_argv *v, int *pos, char *buf) -{ - - v->sz = 0; - v->value = NULL; - - switch (mdoc_argvflags[v->arg]) { - case (ARGV_SINGLE): - return(argv_single(mdoc, line, v, pos, buf)); - case (ARGV_MULTI): - return(argv_multi(mdoc, line, v, pos, buf)); - case (ARGV_OPT_SINGLE): - return(argv_opt_single(mdoc, line, v, pos, buf)); - default: - /* ARGV_NONE */ - break; - } + v->value = mandoc_malloc(sizeof(char *)); + v->value[0] = mandoc_strdup(p); return(1); }