===================================================================
RCS file: /cvs/mandoc/Attic/argv.c,v
retrieving revision 1.2
retrieving revision 1.14
diff -u -p -r1.2 -r1.14
--- mandoc/Attic/argv.c	2008/12/28 00:34:20	1.2
+++ mandoc/Attic/argv.c	2009/01/16 11:50:54	1.14
@@ -1,4 +1,4 @@
-/* $Id: argv.c,v 1.2 2008/12/28 00:34:20 kristaps Exp $ */
+/* $Id: argv.c,v 1.14 2009/01/16 11:50:54 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -27,14 +27,18 @@
 
 
 static	int		 lookup(int, const char *);
-static	int		 parse(struct mdoc *, int, 
+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);
 
 
 int
-mdoc_args(struct mdoc *mdoc, int tok, int *pos, char *buf, int fl, char **v)
+mdoc_args(struct mdoc *mdoc, int line, int *pos, char *buf, int fl, char **v)
 {
 	int		 i;
 
@@ -42,14 +46,18 @@ mdoc_args(struct mdoc *mdoc, int tok, int *pos, char *
 		return(ARGS_EOLN);
 
 	if ('\"' == buf[*pos] && ! (fl & ARGS_QUOTED))
-		if ( ! mdoc_warn(mdoc, tok, *pos, WARN_SYNTAX_QUOTED))
+		if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX, "unexpected quoted parameter"))
 			return(ARGS_ERROR);
 
 	if ('-' == buf[*pos]) 
-		if ( ! mdoc_warn(mdoc, tok, *pos, WARN_SYNTAX_ARGLIKE))
+		if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_SYNTAX, "argument-like parameter"))
 			return(ARGS_ERROR);
 
 	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;
@@ -66,30 +74,48 @@ mdoc_args(struct mdoc *mdoc, int tok, int *pos, char *
 		}
 	}
 
-	/*
-	 * Parse routine for non-quoted string.  
-	 */
+	/* Parse routine for non-quoted string. */
 
 	if ('\"' != buf[*pos]) {
 		*v = &buf[*pos];
 
-		while (buf[*pos] && ! isspace(buf[*pos]))
-			(*pos)++;
+		/* FIXME: UGLY tab-sep processing. */
 
+		if (ARGS_TABSEP & fl)
+			while (buf[*pos]) {
+				if ('\t' == buf[*pos])
+					break;
+				if ('T' == buf[*pos]) {
+					(*pos)++;
+					if (0 == buf[*pos])
+						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);
 
 		buf[(*pos)++] = 0;
+
 		if (0 == buf[*pos])
 			return(ARGS_WORD);
 
-		while (buf[*pos] && isspace(buf[*pos]))
-			(*pos)++;
+		if ( ! (ARGS_TABSEP & fl))
+			while (buf[*pos] && isspace(buf[*pos]))
+				(*pos)++;
 
 		if (buf[*pos])
 			return(ARGS_WORD);
 
-		if ( ! mdoc_warn(mdoc, tok, *pos, WARN_SYNTAX_WS_EOLN))
+		if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_COMPAT, "whitespace at end-of-line"))
 			return(ARGS_ERROR);
 
 		return(ARGS_WORD);
@@ -98,10 +124,8 @@ mdoc_args(struct mdoc *mdoc, int tok, int *pos, char *
 	/*
 	 * 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.  We're not allowed to
-	 * also be DELIM requests (for now).
+	 * error.  After, parse to the next word.  
 	 */
-	assert( ! (fl & ARGS_DELIM));
 
 	*v = &buf[++(*pos)];
 
@@ -109,7 +133,7 @@ mdoc_args(struct mdoc *mdoc, int tok, int *pos, char *
 		(*pos)++;
 
 	if (0 == buf[*pos]) {
-		(void)mdoc_err(mdoc, tok, *pos, ERR_SYNTAX_UNQUOTE);
+		(void)mdoc_perr(mdoc, line, *pos, "unterminated quoted parameter");
 		return(ARGS_ERROR);
 	}
 
@@ -123,7 +147,7 @@ mdoc_args(struct mdoc *mdoc, int tok, int *pos, char *
 	if (buf[*pos])
 		return(ARGS_WORD);
 
-	if ( ! mdoc_warn(mdoc, tok, *pos, WARN_SYNTAX_WS_EOLN))
+	if ( ! mdoc_pwarn(mdoc, line, *pos, WARN_COMPAT, "whitespace at end-of-line"))
 		return(ARGS_ERROR);
 
 	return(ARGS_WORD);
@@ -135,11 +159,20 @@ lookup(int tok, const char *argv)
 {
 
 	switch (tok) {
+	case (MDOC_An):
+		if (xstrcmp(argv, "split"))
+			return(MDOC_Split);
+		else if (xstrcmp(argv, "nosplit"))
+			return(MDOC_Nosplit);
+		break;
+
 	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"))
@@ -148,6 +181,20 @@ lookup(int tok, const char *argv)
 			return(MDOC_Offset);
 		break;
 
+	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;
+
+	case (MDOC_Bk):
+		if (xstrcmp(argv, "words"))
+			return(MDOC_Words);
+		break;
+
 	case (MDOC_Bl):
 		if (xstrcmp(argv, "bullet"))
 			return(MDOC_Bullet);
@@ -178,10 +225,93 @@ lookup(int tok, const char *argv)
 		else if (xstrcmp(argv, "compact"))
 			return(MDOC_Compact);
 		break;
+	
+	case (MDOC_Rv):
+		/* FALLTHROUGH */
+	case (MDOC_Ex):
+		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:
-		abort();
-		/* NOTREACHED */
+		break;
 	}
 
 	return(MDOC_ARG_MAX);
@@ -189,7 +319,7 @@ lookup(int tok, const char *argv)
 
 
 static int
-postparse(struct mdoc *mdoc, int tok, const struct mdoc_arg *v, int pos)
+postparse(struct mdoc *mdoc, int line, const struct mdoc_arg *v, int pos)
 {
 
 	switch (v->arg) {
@@ -206,7 +336,7 @@ postparse(struct mdoc *mdoc, int tok, const struct mdo
 			break;
 		if (xstrcmp(v->value[0], "indent-two"))
 			break;
-		return(mdoc_err(mdoc, tok, pos, ERR_SYNTAX_ARGBAD));
+		return(mdoc_perr(mdoc, line, pos, "invalid offset value"));
 	default:
 		break;
 	}
@@ -216,93 +346,80 @@ postparse(struct mdoc *mdoc, int tok, const struct mdo
 
 
 static int
-parse(struct mdoc *mdoc, int tok, 
+parse_multi(struct mdoc *mdoc, int line, 
 		struct mdoc_arg *v, int *pos, char *buf)
 {
+	int		 c, ppos;
 	char		*p;
-	int		 c, ppos, i;
 
+	v->sz = 0;
+	v->value = xcalloc(MDOC_LINEARG_MAX, sizeof(char *));
+
 	ppos = *pos;
 
+	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);
+		if (ARGS_ERROR == c) {
+			free(v->value);
+			return(0);
+		} else if (ARGS_EOLN == c)
+			break;
+		v->value[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"));
+}
+
+
+static int
+parse_single(struct mdoc *mdoc, int line, 
+		struct mdoc_arg *v, int *pos, char *buf)
+{
+	int		 c, ppos;
+	char		*p;
+
+	ppos = *pos;
+
+	c = mdoc_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"));
+
+	v->sz = 1;
+	v->value = xcalloc(1, sizeof(char *));
+	v->value[0] = p;
+	return(1);
+}
+
+
+static int
+parse(struct mdoc *mdoc, int line, int tok, 
+		struct mdoc_arg *v, int *pos, char *buf)
+{
+
+	v->sz = 0;
+	v->value = NULL;
+
 	switch (v->arg) {
-	case(MDOC_Compact):
+	case(MDOC_Std):
 		/* FALLTHROUGH */
-	case(MDOC_Ragged):
-		/* FALLTHROUGH */
-	case(MDOC_Unfilled):
-		/* FALLTHROUGH */
-	case(MDOC_Literal):
-		/* FALLTHROUGH */
-	case(MDOC_File):
-		/* FALLTHROUGH */
-	case(MDOC_Bullet):
-		/* FALLTHROUGH */
-	case(MDOC_Dash):
-		/* FALLTHROUGH */
-	case(MDOC_Hyphen):
-		/* FALLTHROUGH */
-	case(MDOC_Item):
-		/* FALLTHROUGH */
-	case(MDOC_Enum):
-		/* FALLTHROUGH */
-	case(MDOC_Tag):
-		/* FALLTHROUGH */
-	case(MDOC_Diag):
-		/* FALLTHROUGH */
-	case(MDOC_Hang):
-		/* FALLTHROUGH */
-	case(MDOC_Ohang):
-		/* FALLTHROUGH */
-	case(MDOC_Inset):
-		v->sz = 0;
-		v->value = NULL;
-		break;
-
 	case(MDOC_Width):
 		/* FALLTHROUGH */
 	case(MDOC_Offset):
-		/*
-		 * This has a single value for an argument.
-		 */
-		c = mdoc_args(mdoc, tok, pos, buf, ARGS_QUOTED, &p);
-		if (ARGS_ERROR == c)
-			return(0);
-		else if (ARGS_EOLN == c)
-			return(mdoc_err(mdoc, tok, ppos, ERR_SYNTAX_ARGVAL));
-			
-		v->sz = 1;
-		v->value = xcalloc(1, sizeof(char *));
-		v->value[0] = p;
-		break;
-
+		return(parse_single(mdoc, line, v, pos, buf));
 	case(MDOC_Column):
-		/*
-		 * This has several value for a single argument.  We
-		 * pre-allocate a pointer array and don't let it exceed
-		 * this size.
-		 */
-		v->sz = 0;
-		v->value = xcalloc(MDOC_LINEARG_MAX, sizeof(char *));
-		for (i = 0; i < MDOC_LINEARG_MAX; i++) {
-			c = mdoc_args(mdoc, tok, pos, buf, ARGS_QUOTED, &p);
-			if (ARGS_ERROR == c) {
-				free(v->value);
-				return(0);
-			} else if (ARGS_EOLN == c)
-				break;
-			v->value[i] = p;
-		}
-		if (0 == i) {
-			free(v->value);
-			return(mdoc_err(mdoc, tok, ppos, ERR_SYNTAX_ARGVAL));
-		} else if (MDOC_LINEARG_MAX == i)
-			return(mdoc_err(mdoc, tok, ppos, ERR_SYNTAX_ARGMANY));
-
-		v->sz = i;
-		break;
+		return(parse_multi(mdoc, line, v, pos, buf));
 	default:
-		abort();
-		/* NOTREACHED */
+		break;
 	}
 
 	return(1);
@@ -310,7 +427,7 @@ parse(struct mdoc *mdoc, int tok, 
 
 
 int
-mdoc_argv(struct mdoc *mdoc, int tok, 
+mdoc_argv(struct mdoc *mdoc, int line, int tok,
 		struct mdoc_arg *v, int *pos, char *buf)
 {
 	int		 i, ppos;
@@ -319,18 +436,19 @@ mdoc_argv(struct mdoc *mdoc, int tok, 
 	(void)memset(v, 0, sizeof(struct mdoc_arg));
 
 	if (0 == buf[*pos])
-		return(0);
+		return(ARGV_EOLN);
 
 	assert( ! isspace(buf[*pos]));
 
-	if ('-' != buf[*pos]) {
-		(void)mdoc_err(mdoc, tok, *pos, ERR_SYNTAX_ARGFORM);
-		return(-1);
-	}
+	if ('-' != buf[*pos])
+		return(ARGV_WORD);
 
 	i = *pos;
 	argv = &buf[++(*pos)];
 
+	v->line = line;
+	v->pos = *pos;
+
 	while (buf[*pos] && ! isspace(buf[*pos]))
 		(*pos)++;
 
@@ -338,8 +456,9 @@ mdoc_argv(struct mdoc *mdoc, int tok, 
 		buf[(*pos)++] = 0;
 
 	if (MDOC_ARG_MAX == (v->arg = lookup(tok, argv))) {
-		(void)mdoc_err(mdoc, tok, i, ERR_SYNTAX_ARG);
-		return(-1);
+		if ( ! mdoc_pwarn(mdoc, line, i, WARN_SYNTAX, "argument-like parameter"))
+			return(ARGV_ERROR);
+		return(ARGV_WORD);
 	}
 
 	while (buf[*pos] && isspace(buf[*pos]))
@@ -348,12 +467,12 @@ mdoc_argv(struct mdoc *mdoc, int tok, 
 	/* FIXME: whitespace if no value. */
 
 	ppos = *pos;
-	if ( ! parse(mdoc, tok, v, pos, buf))
-		return(-1);
-	if ( ! postparse(mdoc, tok, v, ppos))
-		return(-1);
+	if ( ! parse(mdoc, line, tok, v, pos, buf))
+		return(ARGV_ERROR);
+	if ( ! postparse(mdoc, line, v, ppos))
+		return(ARGV_ERROR);
 
-	return(1);
+	return(ARGV_ARG);
 }