===================================================================
RCS file: /cvs/mandoc/Attic/mdocml.c,v
retrieving revision 1.44
retrieving revision 1.53
diff -u -p -r1.44 -r1.53
--- mandoc/Attic/mdocml.c	2009/01/15 17:38:57	1.44
+++ mandoc/Attic/mdocml.c	2009/02/20 23:35:36	1.53
@@ -1,4 +1,4 @@
-/* $Id: mdocml.c,v 1.44 2009/01/15 17:38:57 kristaps Exp $ */
+	/* $Id: mdocml.c,v 1.53 2009/02/20 23:35:36 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -30,102 +30,54 @@
 
 #include "mdoc.h"
 
-#define	xfprintf	(void)fprintf
-#define	xprintf		(void)printf
-#define	xvfprintf	(void)fvprintf
-
 #define	MD_LINE_SZ	(256)		/* Max input line size. */
 
 struct	md_parse {
-	int		 warn;		/* Warning flags. */
-#define	MD_WARN_SYNTAX	(1 << 0)	/* Show syntax warnings. */
-#define	MD_WARN_COMPAT	(1 << 1)	/* Show compat warnings. */
-#define	MD_WARN_ALL	(0x03)		/* Show all warnings. */
-#define	MD_WARN_ERR	(1 << 2)	/* Make warnings->errors. */
-	int		 dbg;		/* Debug level. */
-	struct mdoc	*mdoc;		/* Active parser. */
-	char		*buf;		/* Input buffer. */
-	u_long		 bufsz;		/* Input buffer size. */
-	char		*name;		/* Input file name. */
-	int		 fd;		/* Input file desc. */
+	int		  warn;		/* Warning flags. */
+#define	MD_WARN_SYNTAX	 (1 << 0)	/* Show syntax warnings. */
+#define	MD_WARN_COMPAT	 (1 << 1)	/* Show compat warnings. */
+#define	MD_WARN_ALL	 (0x03)		/* Show all warnings. */
+#define	MD_WARN_ERR	 (1 << 2)	/* Make warnings->errors. */
+	int		  dbg;		/* Debug level. */
+	struct mdoc	 *mdoc;		/* Active parser. */
+	char		 *buf;		/* Input buffer. */
+	u_long		  bufsz;	/* Input buffer size. */
+	char		 *in;		/* Input file name. */
+	int		  fdin;		/* Input file desc. */
 };
 
-extern	char	 	*__progname;
+extern	char	 	 *__progname;
 
-static	void		 usage(void);
+static	void		  usage(void);
 
-static	int		 parse_begin(struct md_parse *);
-static	int		 parse_leave(struct md_parse *, int);
-static	int		 io_begin(struct md_parse *);
-static	int		 io_leave(struct md_parse *, int);
-static	int		 buf_begin(struct md_parse *);
-static	int		 buf_leave(struct md_parse *, int);
+static	int		  parse_opts(struct md_parse *, int, char *[]);
+static	int		  parse_subopts(struct md_parse *, char *);
 
-static	void		 msg_msg(void *, int, int, const char *);
-static	int		 msg_err(void *, int, int, const char *);
-static	int		 msg_warn(void *, int, int, 
+static	int		  parse_begin(struct md_parse *);
+static	int		  parse_leave(struct md_parse *, int);
+static	int		  io_begin(struct md_parse *);
+static	int		  io_leave(struct md_parse *, int);
+static	int		  buf_begin(struct md_parse *);
+static	int		  buf_leave(struct md_parse *, int);
+
+static	void		  msg_msg(void *, int, int, const char *);
+static	int		  msg_err(void *, int, int, const char *);
+static	int		  msg_warn(void *, int, int, 
 				enum mdoc_warn, const char *);
 
 #ifdef __linux__
-extern	int		 getsubopt(char **, char *const *, char **);
+extern	int		  getsubopt(char **, char *const *, char **);
 #endif
 
 int
 main(int argc, char *argv[])
 {
-	int		 c;
 	struct md_parse	 parser;
-	char		*opts, *v;
-#define ALL     	 0
-#define COMPAT     	 1
-#define SYNTAX     	 2
-#define ERROR     	 3
-	char		*toks[] = { "all", "compat", "syntax", 
-				    "error", NULL };
 
-	extern char	*optarg;
-	extern int	 optind;
-
 	(void)memset(&parser, 0, sizeof(struct md_parse));
 
-	while (-1 != (c = getopt(argc, argv, "vW:")))
-		switch (c) {
-		case ('v'):
-			parser.dbg++;
-			break;
-		case ('W'):
-			opts = optarg;
-			while (*opts) 
-				switch (getsubopt(&opts, toks, &v)) {
-				case (ALL):
-					parser.warn |= MD_WARN_ALL;
-					break;
-				case (COMPAT):
-					parser.warn |= MD_WARN_COMPAT;
-					break;
-				case (SYNTAX):
-					parser.warn |= MD_WARN_SYNTAX;
-					break;
-				case (ERROR):
-					parser.warn |= MD_WARN_ERR;
-					break;
-				default:
-					usage();
-					return(1);
-				}
-			break;
-		default:
-			usage();
-			return(1);
-		}
-
-	argv += optind;
-	argc -= optind;
-
-	parser.name = "-";
-	if (1 == argc)
-		parser.name = *argv++;
-
+	if ( ! parse_opts(&parser, argc, argv))
+		return(EXIT_FAILURE);
 	if ( ! io_begin(&parser))
 		return(EXIT_FAILURE);
 
@@ -137,11 +89,11 @@ static int
 io_leave(struct md_parse *p, int code)
 {
 
-	if (-1 == p->fd || STDIN_FILENO == p->fd)
+	if (-1 == p->fdin || STDIN_FILENO == p->fdin)
 		return(code);
 
-	if (-1 == close(p->fd)) {
-		warn("%s", p->name);
+	if (-1 == close(p->fdin)) {
+		warn("%s", p->in);
 		code = 0;
 	}
 	return(code);
@@ -149,13 +101,82 @@ io_leave(struct md_parse *p, int code)
 
 
 static int
+parse_subopts(struct md_parse *p, char *arg)
+{
+	char		*v;
+	char		*toks[] = { "all", "compat", 
+				"syntax", "error", NULL };
+
+	/* 
+	 * Future -Wxxx levels and so on should be here.  For now we
+	 * only recognise syntax and compat warnings as categories,
+	 * beyond the usually "all" and "error" (make warn error out).
+	 */
+
+	while (*arg) 
+		switch (getsubopt(&arg, toks, &v)) {
+		case (0):
+			p->warn |= MD_WARN_ALL;
+			break;
+		case (1):
+			p->warn |= MD_WARN_COMPAT;
+			break;
+		case (2):
+			p->warn |= MD_WARN_SYNTAX;
+			break;
+		case (3):
+			p->warn |= MD_WARN_ERR;
+			break;
+		default:
+			usage();
+			return(0);
+		}
+
+	return(1);
+}
+
+
+static int
+parse_opts(struct md_parse *p, int argc, char *argv[])
+{
+	int		 c;
+
+	extern char	*optarg;
+	extern int	 optind;
+
+	p->in = "-";
+
+	while (-1 != (c = getopt(argc, argv, "vW:")))
+		switch (c) {
+		case ('v'):
+			p->dbg++;
+			break;
+		case ('W'):
+			if ( ! parse_subopts(p, optarg))
+				return(0);
+			break;
+		default:
+			usage();
+			return(0);
+		}
+
+	argv += optind;
+	if (0 == (argc -= optind))
+		return(1);
+
+	p->in = *argv++;
+	return(1);
+}
+
+
+static int
 io_begin(struct md_parse *p)
 {
 
-	p->fd = STDIN_FILENO;
-	if (0 != strncmp(p->name, "-", 1))
-		if (-1 == (p->fd = open(p->name, O_RDONLY, 0))) {
-			warn("%s", p->name);
+	p->fdin = STDIN_FILENO;
+	if (0 != strncmp(p->in, "-", 1))
+		if (-1 == (p->fdin = open(p->in, O_RDONLY, 0))) {
+			warn("%s", p->in);
 			return(io_leave(p, 0));
 		}
 
@@ -178,11 +199,17 @@ buf_begin(struct md_parse *p)
 {
 	struct stat	 st;
 
-	if (-1 == fstat(p->fd, &st)) {
-		warn("%s", p->name);
-		return(1);
+	if (-1 == fstat(p->fdin, &st)) {
+		warn("%s", p->in);
+		return(0);
 	} 
 
+	/*
+	 * Try to intuit the fastest way of sucking down buffered data
+	 * by using either the block buffer size or the hard-coded one.
+	 * This is inspired by bin/cat.c.
+	 */
+
 	p->bufsz = MAX(st.st_blksize, BUFSIZ);
 
 	if (NULL == (p->buf = malloc(p->bufsz))) {
@@ -194,93 +221,27 @@ buf_begin(struct md_parse *p)
 }
 
 
-static void
-print_node(const struct mdoc_node *n, int indent)
-{
-	const char	 *p, *t;
-	int		  i, j;
-	size_t		  argc, sz;
-	char		**params;
-	struct mdoc_arg	 *argv;
-
-	argv = NULL;
-	argc = sz = 0;
-	params = NULL;
-
-	t = mdoc_type2a(n->type);
-
-	switch (n->type) {
-	case (MDOC_TEXT):
-		p = n->data.text.string;
-		break;
-	case (MDOC_BODY):
-		p = mdoc_macronames[n->tok];
-		break;
-	case (MDOC_HEAD):
-		p = mdoc_macronames[n->tok];
-		break;
-	case (MDOC_TAIL):
-		p = mdoc_macronames[n->tok];
-		break;
-	case (MDOC_ELEM):
-		p = mdoc_macronames[n->tok];
-		argv = n->data.elem.argv;
-		argc = n->data.elem.argc;
-		break;
-	case (MDOC_BLOCK):
-		p = mdoc_macronames[n->tok];
-		argv = n->data.block.argv;
-		argc = n->data.block.argc;
-		break;
-	case (MDOC_ROOT):
-		p = "root";
-		break;
-	default:
-		abort();
-		/* NOTREACHED */
-	}
-
-	for (i = 0; i < indent; i++)
-		xprintf("    ");
-	xprintf("%s (%s)", p, t);
-
-	for (i = 0; i < (int)argc; i++) {
-		xprintf(" -%s", mdoc_argnames[argv[i].arg]);
-		if (argv[i].sz > 0)
-			xprintf(" [");
-		for (j = 0; j < (int)argv[i].sz; j++)
-			xprintf(" [%s]", argv[i].value[j]);
-		if (argv[i].sz > 0)
-			xprintf(" ]");
-	}
-
-	for (i = 0; i < (int)sz; i++)
-		xprintf(" [%s]", params[i]);
-
-	xprintf(" %d:%d\n", n->line, n->pos);
-
-	if (n->child)
-		print_node(n->child, indent + 1);
-	if (n->next)
-		print_node(n->next, indent);
-}
-
-
 static int
 parse_leave(struct md_parse *p, int code)
 {
-	const struct mdoc_node *n;
+	extern int termprint(const struct mdoc_node *, 
+			const struct mdoc_meta *);
+	/*extern int treeprint(const struct mdoc_node *, 
+			const struct mdoc_meta *);*/
 
 	if (NULL == p->mdoc)
 		return(code);
 
 	if ( ! mdoc_endparse(p->mdoc))
 		code = 0;
-	if ((n = mdoc_result(p->mdoc)))
-		print_node(n, 0);
 
-	mdoc_free(p->mdoc);
+	/* TODO */
+	if (code && ! termprint(mdoc_node(p->mdoc), mdoc_meta(p->mdoc)))
+		code = 0;
+	/*if (code && ! treeprint(mdoc_node(p->mdoc), mdoc_meta(p->mdoc)))
+		code = 0;*/
 
+	mdoc_free(p->mdoc);
 	return(code);
 }
 
@@ -301,9 +262,19 @@ parse_begin(struct md_parse *p)
 	if (NULL == (p->mdoc = mdoc_alloc(p, &cb)))
 		return(parse_leave(p, 0));
 
+	/*
+	 * This is a little more complicated than fgets.  TODO: have
+	 * some benchmarks that show it's faster (note that I want to
+	 * check many, many manuals simultaneously, so speed is
+	 * important).  Fill a buffer (sized to the block size) with a
+	 * single read, then parse \n-terminated lines into a line
+	 * buffer, which is passed to the parser.  Hard-code the line
+	 * buffer to a particular size -- a reasonable assumption.
+	 */
+
 	for (lnn = 1, pos = 0; ; ) {
-		if (-1 == (sz = read(p->fd, p->buf, p->bufsz))) {
-			warn("%s", p->name);
+		if (-1 == (sz = read(p->fdin, p->buf, p->bufsz))) {
+			warn("%s", p->in);
 			return(parse_leave(p, 0));
 		} else if (0 == sz) 
 			break;
@@ -314,8 +285,7 @@ parse_begin(struct md_parse *p)
 					line[(int)pos++] = p->buf[(int)i];
 					continue;
 				}
-				warnx("%s: line %d too long", 
-						p->name, lnn);
+				warnx("%s: line %d too long", p->in, lnn);
 				return(parse_leave(p, 0));
 			}
 	
@@ -339,8 +309,8 @@ msg_err(void *arg, int line, int col, const char *msg)
 
 	p = (struct md_parse *)arg;
 
-	xfprintf(stderr, "%s:%d: error: %s (column %d)", 
-			p->name, line, msg, col);
+	warnx("%s:%d: error: %s (column %d)", 
+			p->in, line, msg, col);
 	return(0);
 }
 
@@ -355,8 +325,8 @@ msg_msg(void *arg, int line, int col, const char *msg)
 	if (0 == p->dbg)
 		return;
 
-	xfprintf(stderr, "%s:%d: debug: %s (column %d)", 
-			p->name, line, msg, col);
+	warnx("%s:%d: debug: %s (column %d)", 
+			p->in, line, msg, col);
 }
 
 
@@ -379,14 +349,13 @@ msg_warn(void *arg, int line, int col, 
 		return(1);
 	}
 
-	xfprintf(stderr, "%s:%d: warning: %s (column %d)\n", 
-			p->name, line, msg, col);
+	warnx("%s:%d: warning: %s (column %d)", 
+			p->in, line, msg, col);
 
 	if ( ! (p->warn & MD_WARN_ERR))
 		return(1);
 
-	xfprintf(stderr, "%s: considering warnings as errors\n", 
-			__progname);
+	warnx("%s: considering warnings as errors", __progname);
 	return(0);
 }
 
@@ -395,7 +364,6 @@ static void
 usage(void)
 {
 
-	xfprintf(stderr, "usage: %s [-v] [-Wwarn...] [infile]\n",
-			__progname);
+	warnx("usage: %s [-v] [-Wwarn...] [infile]", __progname);
 }