===================================================================
RCS file: /cvs/mandoc/Attic/dummy.c,v
retrieving revision 1.4
retrieving revision 1.10
diff -u -p -r1.4 -r1.10
--- mandoc/Attic/dummy.c	2008/11/24 18:32:39	1.4
+++ mandoc/Attic/dummy.c	2008/11/27 17:27:50	1.10
@@ -1,4 +1,4 @@
-/* $Id: dummy.c,v 1.4 2008/11/24 18:32:39 kristaps Exp $ */
+/* $Id: dummy.c,v 1.10 2008/11/27 17:27:50 kristaps Exp $ */
 /*
  * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
  *
@@ -25,134 +25,227 @@
 #include "libmdocml.h"
 #include "private.h"
 
+#ifdef	__linux__
+#define	strlcat		strncat
+#endif
 
-static roffin		in[ROFF_MAX];
-static roffout		out[ROFF_MAX];
-static roffblkin	blkin[ROFF_MAX];
-static roffblkout	blkout[ROFF_MAX];
+static	int		md_dummy_blk_in(const struct md_args *, int);
+static	int		md_dummy_blk_out(const struct md_args *, int);
+static 	int		md_dummy_text_in(const struct md_args *, int,
+				int *, char **);
+static	int		md_dummy_text_out(const struct md_args *, int);
+static	int		md_dummy_special(int);
+static	int		md_dummy_head(void);
+static	int		md_dummy_tail(void);
+static	void		md_dummy_msg(const struct md_args *, 
+				enum roffmsg, const char *,
+				const char *, const char *,
+				int, char *);
 
-static int		md_dummy_blk_in(int);
-static int		md_dummy_blk_out(int);
-static int		md_dummy_text_in(int, int *, char **);
-static int		md_dummy_text_out(int);
+static	void		dbg_prologue(const char *);
+static	void		dbg_epilogue(void);
 
-static void		dbg_indent(void);
+static	int		dbg_lvl = 0;
+static	char		dbg_line[72];
 
-static int		dbg_lvl = 0;
-
 struct	md_dummy {
 	struct rofftree	*tree;
+	struct roffcb	 cb;
 };
 
 
+int
+md_line_dummy(void *arg, char *buf, size_t sz)
+{
+	struct md_dummy	*p;
+
+	p = (struct md_dummy *)arg;
+	return(roff_engine(p->tree, buf, sz));
+}
+
+
+int
+md_exit_dummy(void *data, int flush)
+{
+	int		 c;
+	struct md_dummy	*p;
+
+	p = (struct md_dummy *)data;
+	c = roff_free(p->tree, flush);
+	free(p);
+
+	return(c);
+}
+
+
+void *
+md_init_dummy(const struct md_args *args,
+		struct md_mbuf *mbuf, const struct md_rbuf *rbuf)
+{
+	struct md_dummy	*p;
+
+	if (NULL == (p = malloc(sizeof(struct md_dummy)))) {
+		warn("malloc");
+		return(NULL);
+	}
+
+	p->cb.roffhead = md_dummy_head;
+	p->cb.rofftail = md_dummy_tail;
+	p->cb.roffin = md_dummy_text_in;
+	p->cb.roffout = md_dummy_text_out;
+	p->cb.roffblkin = md_dummy_blk_in;
+	p->cb.roffblkout = md_dummy_blk_out;
+	p->cb.roffspecial = md_dummy_special;
+	p->cb.roffmsg = md_dummy_msg;
+
+	p->tree = roff_alloc(args, mbuf, rbuf, &p->cb);
+
+	if (NULL == p->tree) {
+		free(p);
+		return(NULL);
+	}
+
+	return(p);
+}
+
+
 static void
-dbg_indent(void)
+dbg_prologue(const char *p)
 {
-	char		buf[128];
-	int		i;
+	int		 i;
 
-	*buf = 0;
-	assert(dbg_lvl >= 0);
+	(void)snprintf(dbg_line, sizeof(dbg_line) - 1, "%6s", p);
+	(void)strlcat(dbg_line, ": ", sizeof(dbg_line) - 1);
+	/* LINTED */
 	for (i = 0; i < dbg_lvl; i++)
-		(void)strncat(buf, "  ", sizeof(buf) - 1);
+		(void)strlcat(dbg_line, "    ", sizeof(dbg_line) - 1);
+}
 
-	(void)printf("%s", buf);
+
+static void
+dbg_epilogue(void)
+{
+
+	assert(0 != dbg_line[0]);
+	(void)printf("%s\n", dbg_line);
 }
 
 
 static int
-md_dummy_blk_in(int tok)
+md_dummy_head(void)
 {
 
-	dbg_indent();
-	(void)printf("+++blk\n");
-	dbg_lvl++;
 	return(1);
 }
 
 
 static int
-md_dummy_blk_out(int tok)
+md_dummy_tail(void)
 {
 
-	assert(dbg_lvl > 0);
-	dbg_lvl--;
-	dbg_indent();
-	(void)printf("---blk\n");
 	return(1);
 }
 
 
 static int
-md_dummy_text_in(int tok, int *argcp, char **argvp)
+md_dummy_special(int tok)
 {
 
-	dbg_indent();
-	(void)printf("in: text\n");
+	dbg_prologue("noop");
+	(void)strlcat(dbg_line, toknames[tok], sizeof(dbg_line) - 1);
+	dbg_epilogue();
+
 	return(1);
 }
 
 
 static int
-md_dummy_text_out(int tok)
+md_dummy_blk_in(const struct md_args *args, int tok)
 {
 
-	dbg_indent();
-	(void)printf("out: text\n");
+	if (args->verbosity < 1)
+		return(1);
+
+	dbg_prologue("blk");
+	(void)strlcat(dbg_line, toknames[tok], sizeof(dbg_line) - 1);
+	dbg_epilogue();
+
+	dbg_lvl++;
 	return(1);
 }
 
 
-int
-md_line_dummy(void *arg, char *buf, size_t sz)
+static int
+md_dummy_blk_out(const struct md_args *args, int tok)
 {
-	struct md_dummy	*p;
 
-	p = (struct md_dummy *)arg;
-	return(roff_engine(p->tree, buf, sz));
+	if (args->verbosity < 1)
+		return(1);
+
+	dbg_lvl--;
+	return(1);
 }
 
 
-int
-md_exit_dummy(void *data, int flush)
+static int
+md_dummy_text_in(const struct md_args *args, 
+		int tok, int *argcp, char **argvp)
 {
-	int		 c;
-	struct md_dummy	*p;
 
-	p = (struct md_dummy *)data;
-	c = roff_free(p->tree, flush);
-	free(p);
+	if (args->verbosity < 1)
+		return(1);
 
-	return(c);
+	dbg_prologue("text");
+	(void)strlcat(dbg_line, toknames[tok], sizeof(dbg_line) - 1);
+	(void)strlcat(dbg_line, " ", sizeof(dbg_line) - 1);
+	while (ROFF_ARGMAX != *argcp) {
+		(void)strlcat(dbg_line, "[", sizeof(dbg_line) - 1);
+		(void)strlcat(dbg_line, tokargnames[*argcp], 
+				sizeof(dbg_line) - 1);
+		if (*argvp) {
+			(void)strlcat(dbg_line, " [", 
+					sizeof(dbg_line) - 1);
+			(void)strlcat(dbg_line, *argvp,
+					sizeof(dbg_line) - 1);
+			(void)strlcat(dbg_line, "]", 
+					sizeof(dbg_line) - 1);
+		}
+		(void)strlcat(dbg_line, "]", sizeof(dbg_line) - 1);
+		argcp++;
+		argvp++;
+	}
+	dbg_epilogue();
+	return(1);
 }
 
 
-void *
-md_init_dummy(const struct md_args *args,
-		struct md_mbuf *mbuf, const struct md_rbuf *rbuf)
+static int
+md_dummy_text_out(const struct md_args *args, int tok)
 {
-	struct md_dummy	*p;
-	int		 i;
 
-	for (i = 0; i < ROFF_MAX; i++) {
-		in[i] = md_dummy_text_in;
-		out[i] = md_dummy_text_out;
-		blkin[i] = md_dummy_blk_in;
-		blkout[i] = md_dummy_blk_out;
-	}
+	return(1);
+}
 
-	if (NULL == (p = malloc(sizeof(struct md_dummy)))) {
-		warn("malloc");
-		return(NULL);
-	}
 
-	p->tree = roff_alloc
-		(args, mbuf, rbuf, in, out, blkin, blkout);
+static void
+md_dummy_msg(const struct md_args *args, enum roffmsg lvl, 
+		const char *buf, const char *pos, 
+		const char *name, int line, char *msg)
+{
+	char		*p;
 
-	if (NULL == p->tree) {
-		free(p);
-		return(NULL);
+	switch (lvl) {
+	case (ROFF_WARN):
+		if ( ! (MD_WARN_ALL & args->warnings))
+			return;
+		p = "warning";
+		break;
+	case (ROFF_ERROR):
+		p = "error";
+		break;
 	}
 
-	return(p);
+	assert(pos >= buf);
+	(void)fprintf(stderr, "%s:%d: %s: %s\n", name, line, p, msg);
 }
+