=================================================================== RCS file: /cvs/mandoc/Attic/argv.c,v retrieving revision 1.24 retrieving revision 1.36 diff -u -p -r1.24 -r1.36 --- mandoc/Attic/argv.c 2009/01/21 17:56:32 1.24 +++ mandoc/Attic/argv.c 2009/03/05 12:08:53 1.36 @@ -1,4 +1,4 @@ -/* $Id: argv.c,v 1.24 2009/01/21 17:56:32 kristaps Exp $ */ +/* $Id: argv.c,v 1.36 2009/03/05 12:08:53 kristaps Exp $ */ /* * Copyright (c) 2008 Kristaps Dzonsons * @@ -26,30 +26,114 @@ #include "private.h" /* - * Parse arguments and parameters of macros. Arguments follow the - * syntax of `-arg [val [valN...]]', while parameters are free-form text - * following arguments (if any). This file must correctly handle the - * strange punctuation rules dictated by groff. + * 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. */ #define ARGS_QUOTED (1 << 0) #define ARGS_DELIM (1 << 1) #define ARGS_TABSEP (1 << 2) -static int lookup(int, const char *); -static int parse(struct mdoc *, int, +#define ARGV_NONE (1 << 0) +#define ARGV_SINGLE (1 << 1) +#define ARGV_MULTI (1 << 2) +#define ARGV_OPT_SINGLE (1 << 3) + +static int argv_a2arg(int, const char *); +static int args(struct mdoc *, int, int *, + char *, int, char **); +static int argv(struct mdoc *, int, struct mdoc_arg *, int *, char *); -static int parse_single(struct mdoc *, int, +static int argv_single(struct mdoc *, int, struct mdoc_arg *, int *, char *); -static int parse_multi(struct mdoc *, int, +static int argv_opt_single(struct mdoc *, int, struct mdoc_arg *, int *, char *); -static int postparse(struct mdoc *, int, - const struct mdoc_arg *, int); +static int argv_multi(struct mdoc *, int, + struct mdoc_arg *, int *, char *); static int pwarn(struct mdoc *, int, int, int); +static int perr(struct mdoc *, int, int, int); +/* Warning messages. */ + #define WQUOTPARM (0) #define WARGVPARM (1) +#define WCOLEMPTY (2) +#define WTAILWS (3) +/* Error messages. */ + +#define EQUOTTERM (0) +#define EARGVAL (1) +#define EARGMANY (2) + +/* 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_OPT_SINGLE, /* MDOC_Std */ + ARGV_NONE, /* MDOC_p1003_1_88 */ + ARGV_NONE, /* MDOC_p1003_1_90 */ + ARGV_NONE, /* MDOC_p1003_1_96 */ + ARGV_NONE, /* MDOC_p1003_1_2001 */ + ARGV_NONE, /* MDOC_p1003_1_2004 */ + ARGV_NONE, /* MDOC_p1003_1 */ + ARGV_NONE, /* MDOC_p1003_1b */ + ARGV_NONE, /* MDOC_p1003_1b_93 */ + ARGV_NONE, /* MDOC_p1003_1c_95 */ + ARGV_NONE, /* MDOC_p1003_1g_2000 */ + ARGV_NONE, /* MDOC_p1003_2_92 */ + ARGV_NONE, /* MDOC_p1387_2_95 */ + ARGV_NONE, /* MDOC_p1003_2 */ + ARGV_NONE, /* MDOC_p1387_2 */ + ARGV_NONE, /* MDOC_isoC_90 */ + ARGV_NONE, /* MDOC_isoC_amd1 */ + ARGV_NONE, /* MDOC_isoC_tcor1 */ + ARGV_NONE, /* MDOC_isoC_tcor2 */ + ARGV_NONE, /* MDOC_isoC_99 */ + ARGV_NONE, /* MDOC_ansiC */ + ARGV_NONE, /* MDOC_ansiC_89 */ + ARGV_NONE, /* MDOC_ansiC_99 */ + ARGV_NONE, /* MDOC_ieee754 */ + ARGV_NONE, /* MDOC_iso8802_3 */ + ARGV_NONE, /* MDOC_xpg3 */ + ARGV_NONE, /* MDOC_xpg4 */ + ARGV_NONE, /* MDOC_xpg4_2 */ + ARGV_NONE, /* MDOC_xpg4_3 */ + ARGV_NONE, /* MDOC_xbd5 */ + ARGV_NONE, /* MDOC_xcu5 */ + ARGV_NONE, /* MDOC_xsh5 */ + ARGV_NONE, /* MDOC_xns5 */ + ARGV_NONE, /* MDOC_xns5_2d2_0 */ + ARGV_NONE, /* MDOC_xcurses4_2 */ + ARGV_NONE, /* MDOC_susv2 */ + ARGV_NONE, /* MDOC_susv3 */ + ARGV_NONE, /* MDOC_svid4 */ + 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 */ @@ -64,7 +148,7 @@ static int mdoc_argflags[MDOC_MAX] = { 0, /* Ed */ 0, /* Bl */ 0, /* El */ - ARGS_DELIM, /* It */ + 0, /* It */ ARGS_DELIM, /* Ad */ ARGS_DELIM, /* An */ ARGS_DELIM, /* Ar */ @@ -161,6 +245,32 @@ static int mdoc_argflags[MDOC_MAX] = { static int +perr(struct mdoc *mdoc, int line, int pos, int code) +{ + int c; + + switch (code) { + case (EQUOTTERM): + c = mdoc_perr(mdoc, line, pos, + "unterminated quoted parameter"); + break; + case (EARGVAL): + c = mdoc_perr(mdoc, line, pos, + "argument requires a value"); + break; + case (EARGMANY): + c = mdoc_perr(mdoc, line, pos, + "too many values for argument"); + break; + default: + abort(); + /* NOTREACHED */ + } + return(c); +} + + +static int pwarn(struct mdoc *mdoc, int line, int pos, int code) { int c; @@ -174,6 +284,14 @@ pwarn(struct mdoc *mdoc, int line, int pos, int code) c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, "argument-like parameter"); break; + case (WCOLEMPTY): + c = mdoc_pwarn(mdoc, line, pos, WARN_SYNTAX, + "last list column is empty"); + break; + case (WTAILWS): + c = mdoc_pwarn(mdoc, line, pos, WARN_COMPAT, + "trailing whitespace"); + break; default: abort(); /* NOTREACHED */ @@ -186,17 +304,71 @@ int mdoc_args(struct mdoc *mdoc, int line, int *pos, char *buf, int tok, char **v) { - int i, c, fl; - char *p, *pp; + 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->data.block.argc; + 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->data.block.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; + } + } + 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); - fl = (0 == tok) ? 0 : mdoc_argflags[tok]; - if ('\"' == buf[*pos] && ! (fl & ARGS_QUOTED)) if ( ! pwarn(mdoc, line, *pos, WQUOTPARM)) return(ARGS_ERROR); @@ -206,41 +378,21 @@ mdoc_args(struct mdoc *mdoc, int line, return(ARGS_ERROR); /* - * First see if we should use TABSEP (Bl -column). This - * invalidates the use of ARGS_DELIM. - */ - - if (MDOC_It == tok) { - for (n = mdoc->last; n; n = n->parent) - if (MDOC_BLOCK == n->type) - if (MDOC_Bl == n->tok) - break; - assert(n); - c = (int)n->data.block.argc; - assert(c > 0); - for (i = 0; i < c; i++) { - if (MDOC_Column != n->data.block.argv[i].arg) - continue; - fl |= ARGS_TABSEP; - fl &= ~ARGS_DELIM; - } - } - - /* * 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])) { - for (i = *pos; (c = buf[i]); ) { - if ( ! mdoc_iscdelim(c)) + for (i = *pos; buf[i]; ) { + if ( ! mdoc_iscdelim(buf[i])) break; i++; - if (0 == buf[i] || ! isspace(c)) + /* There must be at least one space... */ + if (0 == buf[i] || ! isspace((int)buf[i])) break; i++; - while (buf[i] && isspace(c)) + while (buf[i] && isspace((int)buf[i])) i++; } if (0 == buf[i]) { @@ -318,32 +470,37 @@ mdoc_args(struct mdoc *mdoc, int line, p++; if (0 != *p) *(p - 1) = 0; - else if (0 == *p) - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX, "empty final token")) /* FIXME: verbiage */ - return(0); - *pos += p - *v; + *pos += (int)(p - *v); } - /* Configure the eoln case, too. */ + 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 (NULL == p) { - p = strchr(*v, 0); - assert(p); + if (p) + return(ARGS_WORD); - /*if (p > *v && ' ' == *(p - 1)) - Warn about whitespace. */ + /* Configure the eoln case, too. */ - *pos += p - *v; - } + 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 ((c = buf[*pos])) { - if (isspace(c)) + while (buf[*pos]) { + if (isspace((int)buf[*pos])) if ('\\' != buf[*pos - 1]) break; (*pos)++; @@ -364,7 +521,7 @@ mdoc_args(struct mdoc *mdoc, int line, if (buf[*pos]) return(ARGS_WORD); - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_COMPAT, "whitespace at end-of-line")) + if ( ! pwarn(mdoc, line, *pos, WTAILWS)) return(ARGS_ERROR); return(ARGS_WORD); @@ -382,7 +539,7 @@ mdoc_args(struct mdoc *mdoc, int line, (*pos)++; if (0 == buf[*pos]) { - (void)mdoc_perr(mdoc, line, *pos, "unterminated quoted parameter"); + (void)perr(mdoc, line, *pos, EQUOTTERM); return(ARGS_ERROR); } @@ -396,7 +553,7 @@ mdoc_args(struct mdoc *mdoc, int line, if (buf[*pos]) return(ARGS_QWORD); - if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_COMPAT, "whitespace at end-of-line")) + if ( ! pwarn(mdoc, line, *pos, WTAILWS)) return(ARGS_ERROR); return(ARGS_QWORD); @@ -404,9 +561,17 @@ mdoc_args(struct mdoc *mdoc, int line, 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")) @@ -568,34 +733,7 @@ lookup(int tok, const char *argv) static int -postparse(struct mdoc *mdoc, int line, const struct mdoc_arg *v, int pos) -{ - - 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, "invalid offset value")); - default: - break; - } - - return(1); -} - - -static int -parse_multi(struct mdoc *mdoc, int line, +argv_multi(struct mdoc *mdoc, int line, struct mdoc_arg *v, int *pos, char *buf) { int c, ppos; @@ -609,27 +747,28 @@ parse_multi(struct mdoc *mdoc, int line, for (v->sz = 0; v->sz < MDOC_LINEARG_MAX; v->sz++) { if ('-' == buf[*pos]) break; - c = mdoc_args(mdoc, line, pos, buf, ARGS_QUOTED, &p); + c = args(mdoc, line, pos, buf, ARGS_QUOTED, &p); if (ARGS_ERROR == c) { free(v->value); return(0); } else if (ARGS_EOLN == c) break; - v->value[v->sz] = p; + v->value[(int)v->sz] = p; } if (0 < v->sz && v->sz < MDOC_LINEARG_MAX) return(1); free(v->value); - return(mdoc_perr(mdoc, line, ppos, 0 == v->sz ? - "argument requires a value" : - "too many values to argument")); + if (0 == v->sz) + return(perr(mdoc, line, ppos, EARGVAL)); + + return(perr(mdoc, line, ppos, EARGMANY)); } static int -parse_single(struct mdoc *mdoc, int line, +argv_opt_single(struct mdoc *mdoc, int line, struct mdoc_arg *v, int *pos, char *buf) { int c, ppos; @@ -637,11 +776,14 @@ parse_single(struct mdoc *mdoc, int line, ppos = *pos; - c = mdoc_args(mdoc, line, pos, buf, ARGS_QUOTED, &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(mdoc_perr(mdoc, line, ppos, "argument requires a value")); + return(1); v->sz = 1; v->value = xcalloc(1, sizeof(char *)); @@ -650,24 +792,53 @@ parse_single(struct mdoc *mdoc, int line, } +/* + * Parse a single, mandatory value from the stream. + */ static int -parse(struct mdoc *mdoc, int line, +argv_single(struct mdoc *mdoc, int line, struct mdoc_arg *v, int *pos, char *buf) { + int c, ppos; + char *p; + ppos = *pos; + + 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] = 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_arg *v, int *pos, char *buf) +{ + v->sz = 0; v->value = NULL; - 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)); + 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; } @@ -675,12 +846,17 @@ parse(struct mdoc *mdoc, int line, } +/* + * 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, struct mdoc_arg *v, int *pos, char *buf) { - int i, ppos; - char *argv; + int i; + char *p; (void)memset(v, 0, sizeof(struct mdoc_arg)); @@ -693,12 +869,14 @@ mdoc_argv(struct mdoc *mdoc, int line, int tok, return(ARGV_WORD); i = *pos; - argv = &buf[++(*pos)]; + p = &buf[++(*pos)]; v->line = line; v->pos = *pos; assert(*pos > 0); + + /* LINTED */ while (buf[*pos]) { if (isspace((int)buf[*pos])) if ('\\' != buf[*pos - 1]) @@ -709,8 +887,14 @@ mdoc_argv(struct mdoc *mdoc, int line, int tok, if (buf[*pos]) buf[(*pos)++] = 0; - if (MDOC_ARG_MAX == (v->arg = lookup(tok, argv))) { - if ( ! mdoc_pwarn(mdoc, line, i, WARN_SYNTAX, "argument-like parameter")) + /* + * 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 == (v->arg = argv_a2arg(tok, p))) { + if ( ! pwarn(mdoc, line, i, WARGVPARM)) return(ARGV_ERROR); return(ARGV_WORD); } @@ -720,10 +904,7 @@ mdoc_argv(struct mdoc *mdoc, int line, int tok, /* FIXME: whitespace if no value. */ - ppos = *pos; - if ( ! parse(mdoc, line, v, pos, buf)) - return(ARGV_ERROR); - if ( ! postparse(mdoc, line, v, ppos)) + if ( ! argv(mdoc, line, v, pos, buf)) return(ARGV_ERROR); return(ARGV_ARG);