=================================================================== RCS file: /cvs/mandoc/mdoc_argv.c,v retrieving revision 1.77 retrieving revision 1.90 diff -u -p -r1.77 -r1.90 --- mandoc/mdoc_argv.c 2011/05/12 23:44:01 1.77 +++ mandoc/mdoc_argv.c 2014/03/23 11:25:26 1.90 @@ -1,6 +1,7 @@ -/* $Id: mdoc_argv.c,v 1.77 2011/05/12 23:44:01 kristaps Exp $ */ +/* $Id: mdoc_argv.c,v 1.90 2014/03/23 11:25:26 schwarze Exp $ */ /* - * Copyright (c) 2008, 2009, 2010 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 @@ -21,13 +22,13 @@ #include #include -#include #include #include #include #include "mdoc.h" #include "mandoc.h" +#include "mandoc_aux.h" #include "libmdoc.h" #include "libmandoc.h" @@ -43,23 +44,22 @@ enum argsflag { 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) */ - ARGV_OPT_SINGLE /* optional arg (e.g., -offset [xxx]) */ + ARGV_MULTI /* multiple args (e.g., -column xxx yyy) */ }; -static enum mdocargt argv_a2arg(enum mdoct, const char *); +struct mdocarg { + enum argsflag flags; + const enum mdocargt *argvs; +}; + +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(struct mdoc *, 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 void argn_free(struct mdoc_arg *, int); static const enum argvflag argvflags[MDOC_ARG_MAX] = { ARGV_NONE, /* MDOC_Split */ @@ -68,7 +68,7 @@ static const enum argvflag argvflags[MDOC_ARG_MAX] = { ARGV_NONE, /* MDOC_Unfilled */ ARGV_NONE, /* MDOC_Literal */ ARGV_SINGLE, /* MDOC_File */ - ARGV_OPT_SINGLE, /* MDOC_Offset */ + ARGV_SINGLE, /* MDOC_Offset */ ARGV_NONE, /* MDOC_Bullet */ ARGV_NONE, /* MDOC_Dash */ ARGV_NONE, /* MDOC_Hyphen */ @@ -90,131 +90,6 @@ static const enum argvflag argvflags[MDOC_ARG_MAX] = { ARGV_NONE /* MDOC_Symbolic */ }; -static const enum argsflag argflags[MDOC_MAX] = { - ARGSFL_NONE, /* Ap */ - ARGSFL_NONE, /* Dd */ - ARGSFL_NONE, /* Dt */ - ARGSFL_NONE, /* Os */ - ARGSFL_NONE, /* Sh */ - ARGSFL_NONE, /* Ss */ - ARGSFL_NONE, /* Pp */ - ARGSFL_DELIM, /* D1 */ - ARGSFL_DELIM, /* Dl */ - ARGSFL_NONE, /* Bd */ - ARGSFL_NONE, /* Ed */ - ARGSFL_NONE, /* Bl */ - ARGSFL_NONE, /* El */ - ARGSFL_NONE, /* It */ - ARGSFL_DELIM, /* Ad */ - ARGSFL_DELIM, /* An */ - ARGSFL_DELIM, /* Ar */ - ARGSFL_NONE, /* Cd */ - ARGSFL_DELIM, /* Cm */ - ARGSFL_DELIM, /* Dv */ - ARGSFL_DELIM, /* Er */ - ARGSFL_DELIM, /* Ev */ - ARGSFL_NONE, /* Ex */ - ARGSFL_DELIM, /* Fa */ - ARGSFL_NONE, /* Fd */ - ARGSFL_DELIM, /* Fl */ - ARGSFL_DELIM, /* Fn */ - ARGSFL_DELIM, /* Ft */ - ARGSFL_DELIM, /* Ic */ - ARGSFL_NONE, /* In */ - ARGSFL_DELIM, /* Li */ - ARGSFL_NONE, /* Nd */ - ARGSFL_DELIM, /* Nm */ - ARGSFL_DELIM, /* Op */ - ARGSFL_NONE, /* Ot */ - ARGSFL_DELIM, /* Pa */ - ARGSFL_NONE, /* Rv */ - ARGSFL_DELIM, /* St */ - ARGSFL_DELIM, /* Va */ - ARGSFL_DELIM, /* Vt */ - ARGSFL_DELIM, /* Xr */ - ARGSFL_NONE, /* %A */ - ARGSFL_NONE, /* %B */ - ARGSFL_NONE, /* %D */ - ARGSFL_NONE, /* %I */ - ARGSFL_NONE, /* %J */ - ARGSFL_NONE, /* %N */ - ARGSFL_NONE, /* %O */ - ARGSFL_NONE, /* %P */ - ARGSFL_NONE, /* %R */ - ARGSFL_NONE, /* %T */ - ARGSFL_NONE, /* %V */ - ARGSFL_DELIM, /* Ac */ - ARGSFL_NONE, /* Ao */ - ARGSFL_DELIM, /* Aq */ - ARGSFL_DELIM, /* At */ - ARGSFL_DELIM, /* Bc */ - ARGSFL_NONE, /* Bf */ - ARGSFL_NONE, /* Bo */ - ARGSFL_DELIM, /* Bq */ - ARGSFL_DELIM, /* Bsx */ - ARGSFL_DELIM, /* Bx */ - ARGSFL_NONE, /* Db */ - ARGSFL_DELIM, /* Dc */ - ARGSFL_NONE, /* Do */ - ARGSFL_DELIM, /* Dq */ - ARGSFL_DELIM, /* Ec */ - ARGSFL_NONE, /* Ef */ - ARGSFL_DELIM, /* Em */ - ARGSFL_NONE, /* Eo */ - ARGSFL_DELIM, /* Fx */ - ARGSFL_DELIM, /* Ms */ - ARGSFL_DELIM, /* No */ - ARGSFL_DELIM, /* Ns */ - ARGSFL_DELIM, /* Nx */ - ARGSFL_DELIM, /* Ox */ - ARGSFL_DELIM, /* Pc */ - ARGSFL_DELIM, /* Pf */ - ARGSFL_NONE, /* Po */ - ARGSFL_DELIM, /* Pq */ - ARGSFL_DELIM, /* Qc */ - ARGSFL_DELIM, /* Ql */ - ARGSFL_NONE, /* Qo */ - ARGSFL_DELIM, /* Qq */ - ARGSFL_NONE, /* Re */ - ARGSFL_NONE, /* Rs */ - ARGSFL_DELIM, /* Sc */ - ARGSFL_NONE, /* So */ - ARGSFL_DELIM, /* Sq */ - ARGSFL_NONE, /* Sm */ - ARGSFL_DELIM, /* Sx */ - ARGSFL_DELIM, /* Sy */ - ARGSFL_DELIM, /* Tn */ - ARGSFL_DELIM, /* Ux */ - ARGSFL_DELIM, /* Xc */ - ARGSFL_NONE, /* Xo */ - ARGSFL_NONE, /* Fo */ - ARGSFL_NONE, /* Fc */ - ARGSFL_NONE, /* Oo */ - ARGSFL_DELIM, /* Oc */ - ARGSFL_NONE, /* Bk */ - ARGSFL_NONE, /* Ek */ - ARGSFL_NONE, /* Bt */ - ARGSFL_NONE, /* Hf */ - ARGSFL_NONE, /* Fr */ - ARGSFL_NONE, /* Ud */ - ARGSFL_NONE, /* Lb */ - ARGSFL_NONE, /* Lp */ - ARGSFL_DELIM, /* Lk */ - ARGSFL_DELIM, /* Mt */ - ARGSFL_DELIM, /* Brq */ - ARGSFL_NONE, /* Bro */ - ARGSFL_DELIM, /* Brc */ - ARGSFL_NONE, /* %C */ - ARGSFL_NONE, /* Es */ - ARGSFL_NONE, /* En */ - ARGSFL_NONE, /* Dx */ - ARGSFL_NONE, /* %Q */ - ARGSFL_NONE, /* br */ - ARGSFL_NONE, /* sp */ - ARGSFL_NONE, /* %U */ - ARGSFL_NONE, /* Ta */ -}; - static const enum mdocargt args_Ex[] = { MDOC_Std, MDOC_ARG_MAX @@ -269,64 +144,215 @@ static const enum mdocargt args_Bl[] = { 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. */ enum margverr -mdoc_argv(struct mdoc *m, int line, enum mdoct tok, +mdoc_argv(struct mdoc *mdoc, int line, enum mdoct tok, struct mdoc_arg **v, int *pos, char *buf) { char *p, sv; struct mdoc_argv tmp; struct mdoc_arg *arg; + const enum mdocargt *ap; if ('\0' == buf[*pos]) return(ARGV_EOLN); + else if (NULL == (ap = mdocargs[tok].argvs)) + return(ARGV_WORD); + else if ('-' != buf[*pos]) + return(ARGV_WORD); - assert(' ' != buf[*pos]); + /* Seek to the first unescaped space. */ - /* Parse through to the first unescaped space. */ - 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]; + if ('\0' != (sv = buf[*pos])) buf[(*pos)++] = '\0'; - } + /* + * 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; return(ARGV_WORD); } + /* Read to the next word (the argument). */ + while (buf[*pos] && ' ' == buf[*pos]) (*pos)++; - if ( ! argv(m, 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)) arg = *v = mandoc_calloc(1, sizeof(struct mdoc_arg)); @@ -382,23 +408,23 @@ argn_free(struct mdoc_arg *p, int iarg) } enum margserr -mdoc_zargs(struct mdoc *m, int line, int *pos, char *buf, char **v) +mdoc_zargs(struct mdoc *mdoc, int line, int *pos, char *buf, char **v) { - return(args(m, line, pos, buf, ARGSFL_NONE, v)); + return(args(mdoc, line, pos, buf, ARGSFL_NONE, v)); } enum margserr -mdoc_args(struct mdoc *m, int line, int *pos, +mdoc_args(struct mdoc *mdoc, int line, int *pos, char *buf, enum mdoct tok, char **v) { enum argsflag fl; struct mdoc_node *n; - fl = argflags[tok]; + fl = mdocargs[tok].flags; if (MDOC_It != tok) - return(args(m, line, pos, buf, fl, v)); + return(args(mdoc, line, pos, buf, fl, v)); /* * We know that we're in an `It', so it's reasonable to expect @@ -407,37 +433,36 @@ mdoc_args(struct mdoc *m, int line, int *pos, * safe fall-back into the default behaviour. */ - for (n = m->last; n; n = n->parent) + for (n = mdoc->last; n; n = n->parent) if (MDOC_Bl == n->tok) if (LIST_column == n->norm->Bl.type) { fl = ARGSFL_TABSEP; break; } - return(args(m, line, pos, buf, fl, v)); + return(args(mdoc, line, pos, buf, fl, v)); } static enum margserr -args(struct mdoc *m, int line, int *pos, +args(struct mdoc *mdoc, int line, int *pos, char *buf, enum argsflag fl, char **v) { char *p, *pp; + int pairs; enum margserr rc; - assert(' ' != buf[*pos]); - if ('\0' == buf[*pos]) { - if (MDOC_PPHRASE & m->flags) + 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 & m->flags) - mdoc_pmsg(m, line, *pos, MANDOCERR_BADQUOTE); + if (MDOC_PHRASELIT & mdoc->flags) + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_BADQUOTE); - m->flags &= ~MDOC_PHRASELIT; + mdoc->flags &= ~MDOC_PHRASELIT; return(ARGS_EOLN); } @@ -460,7 +485,7 @@ args(struct mdoc *m, int line, int *pos, pp = NULL; /* Scan ahead to unescaped `Ta'. */ - if ( ! (MDOC_PHRASELIT & m->flags)) + if ( ! (MDOC_PHRASELIT & mdoc->flags)) for (pp = *v; ; pp++) { if (NULL == (pp = strstr(pp, "Ta"))) break; @@ -494,7 +519,7 @@ args(struct mdoc *m, int line, int *pos, /* Whitespace check for eoln case... */ if ('\0' == *p && ' ' == *(p - 1)) - mdoc_pmsg(m, line, *pos, MANDOCERR_EOLNSPACE); + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_EOLNSPACE); *pos += (int)(p - *v); @@ -512,37 +537,48 @@ args(struct mdoc *m, int line, int *pos, /* Skip ahead. */ ; return(rc); - } + } - /* + /* * 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. */ - if (MDOC_PHRASELIT & m->flags || '\"' == buf[*pos]) { - if ( ! (MDOC_PHRASELIT & m->flags)) + if (MDOC_PHRASELIT & mdoc->flags || '\"' == buf[*pos]) { + if ( ! (MDOC_PHRASELIT & mdoc->flags)) *v = &buf[++(*pos)]; - if (MDOC_PPHRASE & m->flags) - m->flags |= MDOC_PHRASELIT; + if (MDOC_PPHRASE & mdoc->flags) + mdoc->flags |= MDOC_PHRASELIT; + 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'; if ('\0' == buf[*pos]) { - if (MDOC_PPHRASE & m->flags) + if (MDOC_PPHRASE & mdoc->flags) return(ARGS_QWORD); - mdoc_pmsg(m, line, *pos, MANDOCERR_BADQUOTE); + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_BADQUOTE); return(ARGS_QWORD); } - m->flags &= ~MDOC_PHRASELIT; + mdoc->flags &= ~MDOC_PHRASELIT; buf[(*pos)++] = '\0'; if ('\0' == buf[*pos]) @@ -552,13 +588,13 @@ args(struct mdoc *m, int line, int *pos, (*pos)++; if ('\0' == buf[*pos]) - mdoc_pmsg(m, line, *pos, MANDOCERR_EOLNSPACE); + mdoc_pmsg(mdoc, line, *pos, MANDOCERR_EOLNSPACE); return(ARGS_QWORD); } p = &buf[*pos]; - *v = mandoc_getarg(m->parse, &p, line, pos); + *v = mandoc_getarg(mdoc->parse, &p, line, pos); return(ARGS_WORD); } @@ -613,54 +649,8 @@ args_checkpunct(const char *buf, int i) return('\0' == buf[i]); } -/* - * Match up an argument string (e.g., `-foo bar' having "foo") with the - * correrct identifier. It must apply to the given macro. If none was - * found (including bad matches), return MDOC_ARG_MAX. - */ -static enum mdocargt -argv_a2arg(enum mdoct tok, const char *p) -{ - const enum mdocargt *argsp; - - argsp = NULL; - - switch (tok) { - case (MDOC_An): - argsp = args_An; - break; - case (MDOC_Bd): - argsp = args_Bd; - break; - case (MDOC_Bf): - argsp = args_Bf; - break; - case (MDOC_Bk): - argsp = args_Bk; - break; - case (MDOC_Bl): - argsp = args_Bl; - break; - case (MDOC_Rv): - /* FALLTHROUGH */ - case (MDOC_Ex): - argsp = args_Ex; - break; - default: - return(MDOC_ARG_MAX); - } - - assert(argsp); - - for ( ; MDOC_ARG_MAX != *argsp ; argsp++) - if (0 == strcmp(p, mdoc_argnames[*argsp])) - return(*argsp); - - return(MDOC_ARG_MAX); -} - static int -argv_multi(struct mdoc *m, int line, +argv_multi(struct mdoc *mdoc, int line, struct mdoc_argv *v, int *pos, char *buf) { enum margserr ac; @@ -669,7 +659,7 @@ argv_multi(struct mdoc *m, int line, for (v->sz = 0; ; v->sz++) { if ('-' == buf[*pos]) break; - ac = args(m, line, pos, buf, ARGSFL_NONE, &p); + ac = args(mdoc, line, pos, buf, ARGSFL_NONE, &p); if (ARGS_ERROR == ac) return(0); else if (ARGS_EOLN == ac) @@ -686,16 +676,13 @@ argv_multi(struct mdoc *m, int line, } static int -argv_opt_single(struct mdoc *m, int line, +argv_single(struct mdoc *mdoc, int line, struct mdoc_argv *v, int *pos, char *buf) { enum margserr ac; char *p; - if ('-' == buf[*pos]) - return(1); - - ac = args(m, line, pos, buf, ARGSFL_NONE, &p); + ac = args(mdoc, line, pos, buf, ARGSFL_NONE, &p); if (ARGS_ERROR == ac) return(0); if (ARGS_EOLN == ac) @@ -704,63 +691,6 @@ argv_opt_single(struct mdoc *m, int line, v->sz = 1; v->value = mandoc_malloc(sizeof(char *)); v->value[0] = mandoc_strdup(p); - - return(1); -} - -/* - * Parse a single, mandatory value from the stream. - */ -static int -argv_single(struct mdoc *m, int line, - struct mdoc_argv *v, int *pos, char *buf) -{ - int ppos; - enum margserr ac; - char *p; - - ppos = *pos; - - ac = args(m, line, pos, buf, ARGSFL_NONE, &p); - if (ARGS_EOLN == ac) { - mdoc_pmsg(m, line, ppos, MANDOCERR_SYNTARGVCOUNT); - return(0); - } else if (ARGS_ERROR == ac) - return(0); - - v->sz = 1; - v->value = mandoc_malloc(sizeof(char *)); - v->value[0] = mandoc_strdup(p); - - 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 (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)); - case (ARGV_NONE): - break; - default: - abort(); - /* NOTREACHED */ - } return(1); }