First addition of -man macro support.

Abstraction of mdoc.

1 files changed, 368 insertions, 0 deletions

diff --git a/man.c b/man.c
new file mode 100644
index 00000000..ec894c80
--- /dev/null
+++ b/man.c
@@ -0,0 +1,368 @@
+/* $Id: man.c,v 1.1 2009/03/23 14:22:11 kristaps Exp $ */
+/*
+ * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the
+ * above copyright notice and this permission notice appear in all
+ * copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ * PERFORMANCE OF THIS SOFTWARE.
+ */
+#include <assert.h>
+#include <ctype.h>
+#include <err.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "libman.h"
+
+const	char *const __man_macronames[MAN_MAX] = {		 
+	"\\\"",		"TH",		"SH",		"SS",
+	"TP", 		"LP",		"PP",		"P",
+	"IP",		"HP",		"SM",		"SB",
+	"BI",		"IB",		"BR",		"RB",
+	"R",		"B",		"I"
+	};
+
+const	char * const *man_macronames = __man_macronames;
+
+static	struct man_node	*man_node_alloc(int, int, enum man_type);
+static	int		 man_node_append(struct man *, 
+				struct man_node *);
+static	int		 man_ptext(struct man *, int, char *);
+static	int		 man_pmacro(struct man *, int, char *);
+
+
+const struct man_node *
+man_node(const struct man *man)
+{
+
+	return(man->first);
+}
+
+
+const struct man_meta *
+man_meta(const struct man *man)
+{
+
+	return(&man->meta);
+}
+
+
+void
+man_reset(struct man *man)
+{
+
+	if (man->first)
+		man_node_freelist(man->first);
+	if (man->meta.title)
+		free(man->meta.title);
+	if (man->meta.os)
+		free(man->meta.os);
+	if (man->meta.vol)
+		free(man->meta.vol);
+
+	bzero(&man->meta, sizeof(struct man_meta));
+	man->flags = 0;
+	if (NULL == (man->last = calloc(1, sizeof(struct man_node))))
+		err(1, "malloc");
+	man->first = man->last;
+	man->last->type = MAN_ROOT;
+	man->next = MAN_NEXT_CHILD;
+}
+
+
+void
+man_free(struct man *man)
+{
+
+	if (man->first)
+		man_node_freelist(man->first);
+	if (man->meta.title)
+		free(man->meta.title);
+	if (man->meta.os)
+		free(man->meta.os);
+	if (man->meta.vol)
+		free(man->meta.vol);
+	if (man->htab)
+		man_hash_free(man->htab);
+	free(man);
+}
+
+
+struct man *
+man_alloc(void)
+{
+	struct man	*p;
+
+	if (NULL == (p = calloc(1, sizeof(struct man))))
+		err(1, "malloc");
+	if (NULL == (p->last = calloc(1, sizeof(struct man_node))))
+		err(1, "malloc");
+
+	p->first = p->last;
+	p->last->type = MAN_ROOT;
+	p->next = MAN_NEXT_CHILD;
+	p->htab = man_hash_alloc();
+	return(p);
+}
+
+
+int
+man_endparse(struct man *m)
+{
+
+	return(1);
+}
+
+
+int
+man_parseln(struct man *m, int ln, char *buf)
+{
+
+	return('.' == *buf ? 
+			man_pmacro(m, ln, buf) : 
+			man_ptext(m, ln, buf));
+}
+
+
+static int
+man_node_append(struct man *man, struct man_node *p)
+{
+
+	assert(man->last);
+	assert(man->first);
+	assert(MAN_ROOT != p->type);
+
+	switch (man->next) {
+	case (MAN_NEXT_SIBLING):
+		man->last->next = p;
+		p->prev = man->last;
+		p->parent = man->last->parent;
+		break;
+	case (MAN_NEXT_CHILD):
+		man->last->child = p;
+		p->parent = man->last;
+		break;
+	default:
+		abort();
+		/* NOTREACHED */
+	}
+
+#if 0
+	if ( ! man_valid_pre(man, p))
+		return(0);
+	if ( ! man_action_pre(man, p))
+		return(0);
+#endif
+
+	switch (p->type) {
+	case (MAN_HEAD):
+		assert(MAN_BLOCK == p->parent->type);
+		p->parent->head = p;
+		break;
+	case (MAN_BODY):
+		assert(MAN_BLOCK == p->parent->type);
+		p->parent->body = p;
+		break;
+	default:
+		break;
+	}
+
+	man->last = p;
+	return(1);
+}
+
+
+static struct man_node *
+man_node_alloc(int line, int pos, enum man_type type)
+{
+	struct man_node *p;
+
+	if (NULL == (p = calloc(1, sizeof(struct man_node))))
+		err(1, "malloc");
+	p->line = line;
+	p->pos = pos;
+	p->type = type;
+
+	return(p);
+}
+
+
+int
+man_head_alloc(struct man *man, int line, int pos, int tok)
+{
+	struct man_node	*p;
+
+	p = man_node_alloc(line, pos, MAN_HEAD);
+	p->tok = tok;
+
+	return(man_node_append(man, p));
+}
+
+
+int
+man_body_alloc(struct man *man, int line, int pos, int tok)
+{
+	struct man_node	*p;
+
+	p = man_node_alloc(line, pos, MAN_BODY);
+	p->tok = tok;
+
+	return(man_node_append(man, p));
+}
+
+
+int
+man_block_alloc(struct man *man, int line, int pos, int tok)
+{
+	struct man_node	*p;
+
+	p = man_node_alloc(line, pos, MAN_BLOCK);
+	p->tok = tok;
+
+	return(man_node_append(man, p));
+}
+
+
+int
+man_elem_alloc(struct man *man, int line, int pos, int tok)
+{
+	struct man_node *p;
+
+	p = man_node_alloc(line, pos, MAN_ELEM);
+	p->tok = tok;
+
+	return(man_node_append(man, p));
+}
+
+
+int
+man_word_alloc(struct man *man, 
+		int line, int pos, const char *word)
+{
+	struct man_node	*p;
+
+	p = man_node_alloc(line, pos, MAN_TEXT);
+	if (NULL == (p->string = strdup(word)))
+		err(1, "strdup");
+
+	return(man_node_append(man, p));
+}
+
+
+void
+man_node_free(struct man_node *p)
+{
+
+	if (p->string)
+		free(p->string);
+	free(p);
+}
+
+
+void
+man_node_freelist(struct man_node *p)
+{
+
+	if (p->child)
+		man_node_freelist(p->child);
+	if (p->next)
+		man_node_freelist(p->next);
+
+	man_node_free(p);
+}
+
+
+static int
+man_ptext(struct man *m, int line, char *buf)
+{
+
+	if (0 == buf[0]) {
+		warnx("blank line!");
+		return(1);
+	}
+
+	if ( ! man_word_alloc(m, line, 0, buf))
+		return(0);
+
+	m->next = MAN_NEXT_SIBLING;
+	return(1);
+}
+
+
+int
+man_pmacro(struct man *m, int ln, char *buf)
+{
+	int		  i, c;
+	char		  mac[5];
+
+	/* Comments and empties are quickly ignored. */
+
+	if (0 == buf[1])
+		return(1);
+
+	if (' ' == buf[1]) {
+		i = 2;
+		while (buf[i] && ' ' == buf[i])
+			i++;
+		if (0 == buf[i])
+			return(1);
+		warnx("invalid syntax");
+		return(0);
+	}
+
+	if (buf[1] && '\\' == buf[1])
+		if (buf[2] && '\"' == buf[2])
+			return(1);
+
+	/* Copy the first word into a nil-terminated buffer. */
+
+	for (i = 1; i < 5; i++) {
+		if (0 == (mac[i - 1] = buf[i]))
+			break;
+		else if (' ' == buf[i])
+			break;
+	}
+
+	mac[i - 1] = 0;
+
+	if (i == 5 || i <= 1) {
+		warnx("unknown macro: %s", mac);
+		goto err;
+	} 
+	
+	if (MAN_MAX == (c = man_hash_find(m->htab, mac))) {
+		warnx("unknown macro: %s", mac);
+		goto err;
+	}
+
+	/* The macro is sane.  Jump to the next word. */
+
+	while (buf[i] && ' ' == buf[i])
+		i++;
+
+	/* Begin recursive parse sequence. */
+
+	if ( ! (*man_macros[c].fp)(m, c, ln, 1, &i, buf))
+		goto err;
+
+	return(1);
+
+err:	/* Error out. */
+
+#if 0
+	m->flags |= MDOC_HALT;
+#endif
+	return(0);
+}