=================================================================== RCS file: /cvs/mandoc/Attic/argv.c,v retrieving revision 1.12 retrieving revision 1.43 diff -u -p -r1.12 -r1.43 --- mandoc/Attic/argv.c 2009/01/12 16:39:57 1.12 +++ mandoc/Attic/argv.c 2009/03/08 20:57:35 1.43 @@ -1,4 +1,4 @@ -/* $Id: argv.c,v 1.12 2009/01/12 16:39:57 kristaps Exp $ */ +/* $Id: argv.c,v 1.43 2009/03/08 20:57:35 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -25,47 +25,450 @@ #include "private.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. + */ -static int lookup(int, const char *); -static int parse(struct mdoc *, int, int, - struct mdoc_arg *, int *, char *); -static int parse_single(struct mdoc *, int, - struct mdoc_arg *, int *, char *); -static int parse_multi(struct mdoc *, int, - struct mdoc_arg *, int *, char *); -static int postparse(struct mdoc *, int, - const struct mdoc_arg *, int); +#define ARGS_QUOTED (1 << 0) +#define ARGS_DELIM (1 << 1) +#define ARGS_TABSEP (1 << 2) +#define ARGS_ARGVLIKE (1 << 3) +#define ARGV_NONE (1 << 0) +#define ARGV_SINGLE (1 << 1) +#define ARGV_MULTI (1 << 2) +#define ARGV_OPT_SINGLE (1 << 3) +enum mwarn { + WQUOTPARM, + WARGVPARM, + WCOLEMPTY, + WTAILWS +}; + +enum merr { + EQUOTTERM, + EARGVAL +}; + +static int argv_a2arg(int, const char *); +static int args(struct mdoc *, int, int *, + char *, int, char **); +static int argv(struct mdoc *, int, 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] = { + 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_Offset */ + ARGV_NONE, /* MDOC_Bullet */ + ARGV_NONE, /* MDOC_Dash */ + ARGV_NONE, /* MDOC_Hyphen */ + ARGV_NONE, /* MDOC_Item */ + ARGV_NONE, /* MDOC_Enum */ + ARGV_NONE, /* MDOC_Tag */ + ARGV_NONE, /* MDOC_Diag */ + ARGV_NONE, /* MDOC_Hang */ + ARGV_NONE, /* MDOC_Ohang */ + ARGV_NONE, /* MDOC_Inset */ + ARGV_MULTI, /* MDOC_Column */ + ARGV_SINGLE, /* MDOC_Width */ + ARGV_NONE, /* MDOC_Compact */ + ARGV_SINGLE, /* MDOC_Std */ + ARGV_NONE, /* MDOC_Filled */ + ARGV_NONE, /* MDOC_Words */ + ARGV_NONE, /* MDOC_Emphasis */ + ARGV_NONE /* MDOC_Symbolic */ +}; + +static int mdoc_argflags[MDOC_MAX] = { + 0, /* \" */ + 0, /* Dd */ + 0, /* Dt */ + 0, /* Os */ + 0, /* Sh */ + 0, /* Ss */ + ARGS_DELIM, /* Pp */ + ARGS_DELIM, /* D1 */ + ARGS_DELIM, /* Dl */ + 0, /* Bd */ + 0, /* Ed */ + 0, /* Bl */ + 0, /* El */ + 0, /* It */ + ARGS_DELIM, /* Ad */ + ARGS_DELIM, /* An */ + ARGS_DELIM, /* 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, /* Li */ + 0, /* 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, /* Sy */ + ARGS_DELIM, /* Tn */ + ARGS_DELIM, /* Ux */ + ARGS_DELIM, /* Xc */ + 0, /* Xo */ + 0, /* Fo */ + 0, /* Fc */ + 0, /* Oo */ + ARGS_DELIM, /* Oc */ + 0, /* Bk */ + 0, /* Ek */ + 0, /* Bt */ + 0, /* Hf */ + 0, /* Fr */ + 0, /* Ud */ + 0, /* Lb */ + 0, /* Ap */ + 0, /* Lp */ +}; + + +/* + * 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_args(struct mdoc *mdoc, int line, int *pos, char *buf, int fl, char **v) +mdoc_argv(struct mdoc *mdoc, int line, int tok, + struct mdoc_arg **v, int *pos, char *buf) { - int i; + int i; + char *p; + struct mdoc_argv tmp; + struct mdoc_arg *arg; if (0 == buf[*pos]) + return(ARGV_EOLN); + + assert( ! isspace((u_char)buf[*pos])); + + if ('-' != buf[*pos]) + return(ARGV_WORD); + + i = *pos; + p = &buf[++(*pos)]; + + assert(*pos > 0); + + /* LINTED */ + while (buf[*pos]) { + if (isspace((u_char)buf[*pos])) + if ('\\' != buf[*pos - 1]) + break; + (*pos)++; + } + + if (buf[*pos]) + buf[(*pos)++] = 0; + + (void)memset(&tmp, 0, sizeof(struct mdoc_argv)); + tmp.line = line; + tmp.pos = *pos; + + /* + * We now parse out the per-macro arguments. XXX - this can be + * made much cleaner using per-argument tables. See argv_a2arg + * for details. + */ + + if (MDOC_ARG_MAX == (tmp.arg = argv_a2arg(tok, p))) { + if ( ! pwarn(mdoc, line, i, WARGVPARM)) + return(ARGV_ERROR); + return(ARGV_WORD); + } + + while (buf[*pos] && isspace((u_char)buf[*pos])) + (*pos)++; + + /* FIXME: whitespace if no value. */ + + if ( ! argv(mdoc, tok, line, &tmp, pos, buf)) + return(ARGV_ERROR); + + if (NULL == (arg = *v)) { + *v = xcalloc(1, sizeof(struct mdoc_arg)); + arg = *v; + } + + arg->argc++; + arg->argv = xrealloc(arg->argv, arg->argc * + sizeof(struct mdoc_argv)); + + (void)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; + + if (NULL == p) + return; + + if (p->refcnt) { + --(p->refcnt); + 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]); + + free(p->argv[i].value); + } + + free(p->argv); + free(p); +} + + + +static int +perr(struct mdoc *mdoc, int line, int pos, enum merr code) +{ + char *p; + + p = NULL; + + switch (code) { + case (EQUOTTERM): + p = "unterminated quoted parameter"; + break; + case (EARGVAL): + p = "argument requires a value"; + break; + } + + assert(p); + return(mdoc_perr(mdoc, line, pos, p)); +} + + +static int +pwarn(struct mdoc *mdoc, int line, int pos, enum mwarn code) +{ + 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)); +} + + +int +mdoc_args(struct mdoc *mdoc, int line, + int *pos, char *buf, int tok, char **v) +{ + int fl, c, i; + struct mdoc_node *n; + + fl = (0 == tok) ? 0 : mdoc_argflags[tok]; + + /* + * Override per-macro argument flags with context-specific ones. + * As of now, this is only valid for `It' depending on its list + * context. + */ + + switch (tok) { + case (MDOC_It): + for (n = mdoc->last; n; n = n->parent) + if (MDOC_BLOCK == n->type && MDOC_Bl == n->tok) + 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; + } + + /* Continue parsing the arguments themselves... */ + + return(args(mdoc, line, pos, buf, fl, v)); +} + + +static int +args(struct mdoc *mdoc, int line, + int *pos, char *buf, int fl, char **v) +{ + int i; + char *p, *pp; + + assert(*pos > 0); + + if (0 == buf[*pos]) return(ARGS_EOLN); if ('\"' == buf[*pos] && ! (fl & ARGS_QUOTED)) - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX_QUOTED)) + if ( ! pwarn(mdoc, line, *pos, WQUOTPARM)) return(ARGS_ERROR); - if ('-' == buf[*pos]) - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX_ARGLIKE)) + if ( ! (fl & ARGS_ARGVLIKE) && '-' == buf[*pos]) + if ( ! pwarn(mdoc, line, *pos, WARGVPARM)) return(ARGS_ERROR); + /* + * 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::][ ]+]+. + */ + if ((fl & ARGS_DELIM) && mdoc_iscdelim(buf[*pos])) { - /* - * If ARGS_DELIM, return ARGS_PUNCT if only space-separated - * punctuation remains. - */ for (i = *pos; buf[i]; ) { if ( ! mdoc_iscdelim(buf[i])) break; i++; - if (0 == buf[i] || ! isspace(buf[i])) + /* There must be at least one space... */ + if (0 == buf[i] || ! isspace((u_char)buf[i])) break; i++; - while (buf[i] && isspace(buf[i])) + while (buf[i] && isspace((u_char)buf[i])) i++; } if (0 == buf[i]) { @@ -74,31 +477,110 @@ mdoc_args(struct mdoc *mdoc, int line, int *pos, char } } - /* Parse routine for non-quoted string. */ + /* First parse non-quoted strings. */ - if ('\"' != buf[*pos]) { + if ('\"' != buf[*pos] || ! (ARGS_QUOTED & fl)) { *v = &buf[*pos]; - /* FIXME: UGLY tab-sep processing. */ + /* + * Thar be dragons here! If we're tab-separated, search + * ahead for either a tab or the `Ta' macro. If a tab + * is detected, it mustn't be escaped; 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) - while (buf[*pos]) { - if ('\t' == buf[*pos]) + if (ARGS_TABSEP & fl) { + /* Scan ahead to unescaped tab. */ + + for (p = *v; ; p++) { + if (NULL == (p = strchr(p, '\t'))) break; - if ('T' == buf[*pos]) { - (*pos)++; - if (0 == buf[*pos]) + if (p == *v) + break; + if ('\\' != *(p - 1)) + break; + } + + /* Scan ahead to unescaped `Ta'. */ + + for (pp = *v; ; pp++) { + if (NULL == (pp = strstr(pp, "Ta"))) + break; + if (pp > *v && ' ' != *(pp - 1)) + continue; + if (' ' == *(pp + 2) || 0 == *(pp + 2)) + break; + } + + /* Choose delimiter tab/Ta. */ + + 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_WORD); + + /* Configure the eoln case, too. */ + + p = strchr(*v, 0); + assert(p); + + if (p > *v && ' ' == *(p - 1)) + if ( ! pwarn(mdoc, line, *pos, WTAILWS)) + return(0); + *pos += (int)(p - *v); + + return(ARGS_WORD); + } + + /* Do non-tabsep look-ahead here. */ + + if ( ! (ARGS_TABSEP & fl)) + while (buf[*pos]) { + if (isspace((u_char)buf[*pos])) + if ('\\' != buf[*pos - 1]) break; - if ('a' == buf[*pos]) { - buf[*pos - 1] = 0; - break; - } - } (*pos)++; } - else - while (buf[*pos] && ! isspace(buf[*pos])) - (*pos)++; if (0 == buf[*pos]) return(ARGS_WORD); @@ -109,13 +591,13 @@ mdoc_args(struct mdoc *mdoc, int line, int *pos, char return(ARGS_WORD); if ( ! (ARGS_TABSEP & fl)) - while (buf[*pos] && isspace(buf[*pos])) + while (buf[*pos] && isspace((u_char)buf[*pos])) (*pos)++; if (buf[*pos]) return(ARGS_WORD); - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX_WS_EOLN)) + if ( ! pwarn(mdoc, line, *pos, WTAILWS)) return(ARGS_ERROR); return(ARGS_WORD); @@ -127,39 +609,45 @@ mdoc_args(struct mdoc *mdoc, int line, int *pos, char * error. After, parse to the next word. */ - assert( ! (ARGS_TABSEP & fl)); - *v = &buf[++(*pos)]; while (buf[*pos] && '\"' != buf[*pos]) (*pos)++; if (0 == buf[*pos]) { - (void)mdoc_perr(mdoc, line, *pos, ERR_SYNTAX_UNQUOTE); + (void)perr(mdoc, line, *pos, EQUOTTERM); return(ARGS_ERROR); } buf[(*pos)++] = 0; if (0 == buf[*pos]) - return(ARGS_WORD); + return(ARGS_QWORD); - while (buf[*pos] && isspace(buf[*pos])) + while (buf[*pos] && isspace((u_char)buf[*pos])) (*pos)++; if (buf[*pos]) - return(ARGS_WORD); + return(ARGS_QWORD); - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX_WS_EOLN)) + if ( ! pwarn(mdoc, line, *pos, WTAILWS)) return(ARGS_ERROR); - return(ARGS_WORD); + return(ARGS_QWORD); } static int -lookup(int tok, const char *argv) +argv_a2arg(int tok, const char *argv) { + /* + * 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! + */ + switch (tok) { case (MDOC_An): if (xstrcmp(argv, "split")) @@ -173,6 +661,8 @@ lookup(int tok, const char *argv) 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")) @@ -232,84 +722,6 @@ lookup(int tok, const char *argv) if (xstrcmp(argv, "std")) return(MDOC_Std); break; - - case (MDOC_St): - if (xstrcmp(argv, "p1003.1-88")) - return(MDOC_p1003_1_88); - else if (xstrcmp(argv, "p1003.1-90")) - return(MDOC_p1003_1_90); - else if (xstrcmp(argv, "p1003.1-96")) - return(MDOC_p1003_1_96); - else if (xstrcmp(argv, "p1003.1-2001")) - return(MDOC_p1003_1_2001); - else if (xstrcmp(argv, "p1003.1-2004")) - return(MDOC_p1003_1_2004); - else if (xstrcmp(argv, "p1003.1")) - return(MDOC_p1003_1); - else if (xstrcmp(argv, "p1003.1b")) - return(MDOC_p1003_1b); - else if (xstrcmp(argv, "p1003.1b-93")) - return(MDOC_p1003_1b_93); - else if (xstrcmp(argv, "p1003.1c-95")) - return(MDOC_p1003_1c_95); - else if (xstrcmp(argv, "p1003.1g-2000")) - return(MDOC_p1003_1g_2000); - else if (xstrcmp(argv, "p1003.2-92")) - return(MDOC_p1003_2_92); - else if (xstrcmp(argv, "p1003.2-95")) - return(MDOC_p1387_2_95); - else if (xstrcmp(argv, "p1003.2")) - return(MDOC_p1003_2); - else if (xstrcmp(argv, "p1387.2-95")) - return(MDOC_p1387_2); - else if (xstrcmp(argv, "isoC-90")) - return(MDOC_isoC_90); - else if (xstrcmp(argv, "isoC-amd1")) - return(MDOC_isoC_amd1); - else if (xstrcmp(argv, "isoC-tcor1")) - return(MDOC_isoC_tcor1); - else if (xstrcmp(argv, "isoC-tcor2")) - return(MDOC_isoC_tcor2); - else if (xstrcmp(argv, "isoC-99")) - return(MDOC_isoC_99); - else if (xstrcmp(argv, "ansiC")) - return(MDOC_ansiC); - else if (xstrcmp(argv, "ansiC-89")) - return(MDOC_ansiC_89); - else if (xstrcmp(argv, "ansiC-99")) - return(MDOC_ansiC_99); - else if (xstrcmp(argv, "ieee754")) - return(MDOC_ieee754); - else if (xstrcmp(argv, "iso8802-3")) - return(MDOC_iso8802_3); - else if (xstrcmp(argv, "xpg3")) - return(MDOC_xpg3); - else if (xstrcmp(argv, "xpg4")) - return(MDOC_xpg4); - else if (xstrcmp(argv, "xpg4.2")) - return(MDOC_xpg4_2); - else if (xstrcmp(argv, "xpg4.3")) - return(MDOC_xpg4_3); - else if (xstrcmp(argv, "xbd5")) - return(MDOC_xbd5); - else if (xstrcmp(argv, "xcu5")) - return(MDOC_xcu5); - else if (xstrcmp(argv, "xsh5")) - return(MDOC_xsh5); - else if (xstrcmp(argv, "xns5")) - return(MDOC_xns5); - else if (xstrcmp(argv, "xns5.2d2.0")) - return(MDOC_xns5_2d2_0); - else if (xstrcmp(argv, "xcurses4.2")) - return(MDOC_xcurses4_2); - else if (xstrcmp(argv, "susv2")) - return(MDOC_susv2); - else if (xstrcmp(argv, "susv3")) - return(MDOC_susv3); - else if (xstrcmp(argv, "svid4")) - return(MDOC_svid4); - break; - default: break; } @@ -319,173 +731,123 @@ lookup(int tok, const char *argv) static int -postparse(struct mdoc *mdoc, int line, const struct mdoc_arg *v, int pos) +argv_multi(struct mdoc *mdoc, int line, + struct mdoc_argv *v, int *pos, char *buf) { - - switch (v->arg) { - case (MDOC_Offset): - assert(v->value); - assert(v->value[0]); - if (xstrcmp(v->value[0], "left")) - break; - if (xstrcmp(v->value[0], "right")) - break; - if (xstrcmp(v->value[0], "center")) - break; - if (xstrcmp(v->value[0], "indent")) - break; - if (xstrcmp(v->value[0], "indent-two")) - break; - return(mdoc_perr(mdoc, line, pos, ERR_SYNTAX_ARGBAD)); - default: - break; - } - - return(1); -} - - -static int -parse_multi(struct mdoc *mdoc, int line, - struct mdoc_arg *v, int *pos, char *buf) -{ int c, ppos; char *p; - v->sz = 0; - v->value = xcalloc(MDOC_LINEARG_MAX, sizeof(char *)); - ppos = *pos; - for (v->sz = 0; v->sz < MDOC_LINEARG_MAX; v->sz++) { + for (v->sz = 0; ; v->sz++) { if ('-' == buf[*pos]) break; - c = mdoc_args(mdoc, line, pos, buf, ARGS_QUOTED, &p); - if (ARGS_ERROR == c) { - free(v->value); + c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); + if (ARGS_ERROR == c) return(0); - } else if (ARGS_EOLN == c) + else if (ARGS_EOLN == c) break; - v->value[v->sz] = p; + + if (0 == v->sz % 5) + v->value = xrealloc(v->value, + (v->sz + 5) * sizeof(char *)); + + v->value[(int)v->sz] = xstrdup(p); } - if (0 < v->sz && v->sz < MDOC_LINEARG_MAX) + if (v->sz) return(1); - c = 0 == v->sz ? ERR_SYNTAX_ARGVAL : ERR_SYNTAX_ARGMANY; - free(v->value); - return(mdoc_perr(mdoc, line, ppos, c)); + return(perr(mdoc, line, ppos, EARGVAL)); } static int -parse_single(struct mdoc *mdoc, int line, - struct mdoc_arg *v, int *pos, char *buf) +argv_opt_single(struct mdoc *mdoc, int line, + struct mdoc_argv *v, int *pos, char *buf) { - int c, ppos; + int c; char *p; - ppos = *pos; + if ('-' == buf[*pos]) + return(1); - c = mdoc_args(mdoc, line, pos, buf, ARGS_QUOTED, &p); + c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); if (ARGS_ERROR == c) return(0); if (ARGS_EOLN == c) - return(mdoc_perr(mdoc, line, ppos, ERR_SYNTAX_ARGVAL)); + return(1); v->sz = 1; v->value = xcalloc(1, sizeof(char *)); - v->value[0] = p; + v->value[0] = xstrdup(p); return(1); } +/* + * Parse a single, mandatory value from the stream. + */ static int -parse(struct mdoc *mdoc, int line, int tok, - struct mdoc_arg *v, int *pos, char *buf) +argv_single(struct mdoc *mdoc, int line, + struct mdoc_argv *v, int *pos, char *buf) { + int c, ppos; + char *p; - v->sz = 0; - v->value = NULL; + ppos = *pos; - switch (v->arg) { - case(MDOC_Std): - /* FALLTHROUGH */ - case(MDOC_Width): - /* FALLTHROUGH */ - case(MDOC_Offset): - return(parse_single(mdoc, line, v, pos, buf)); - case(MDOC_Column): - return(parse_multi(mdoc, line, v, pos, buf)); - default: - break; - } + c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); + if (ARGS_ERROR == c) + return(0); + if (ARGS_EOLN == c) + return(perr(mdoc, line, ppos, EARGVAL)); + v->sz = 1; + v->value = xcalloc(1, sizeof(char *)); + v->value[0] = xstrdup(p); return(1); } -int -mdoc_argv(struct mdoc *mdoc, int line, int tok, - struct mdoc_arg *v, int *pos, char *buf) +/* + * 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 tok, int line, + struct mdoc_argv *v, int *pos, char *buf) { - int i, ppos; - char *argv; + int fl; - (void)memset(v, 0, sizeof(struct mdoc_arg)); + v->sz = 0; + v->value = NULL; + fl = mdoc_argvflags[v->arg]; - if (0 == buf[*pos]) - return(ARGV_EOLN); + /* + * Override the default per-argument value. + */ - assert( ! isspace(buf[*pos])); - - if ('-' != buf[*pos]) - return(ARGV_WORD); - - i = *pos; - argv = &buf[++(*pos)]; - - v->line = line; - v->pos = *pos; - - while (buf[*pos] && ! isspace(buf[*pos])) - (*pos)++; - - if (buf[*pos]) - buf[(*pos)++] = 0; - - if (MDOC_ARG_MAX == (v->arg = lookup(tok, argv))) { - (void)mdoc_pwarn(mdoc, line, i, WARN_SYNTAX_ARGLIKE); - return(ARGV_WORD); + switch (tok) { + case (MDOC_Ex): + fl = ARGV_OPT_SINGLE; + break; + default: + break; } - while (buf[*pos] && isspace(buf[*pos])) - (*pos)++; - - /* FIXME: whitespace if no value. */ - - ppos = *pos; - if ( ! parse(mdoc, line, tok, v, pos, buf)) - return(ARGV_ERROR); - if ( ! postparse(mdoc, line, v, ppos)) - return(ARGV_ERROR); - - return(ARGV_ARG); -} - - -void -mdoc_argv_free(int sz, struct mdoc_arg *arg) -{ - int i; - - for (i = 0; i < sz; i++) { - if (0 == arg[i].sz) { - assert(NULL == arg[i].value); - continue; - } - assert(arg[i].value); - free(arg[i].value); + switch (fl) { + 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; } -} + return(1); +}