===================================================================
RCS file: /cvs/mandoc/roff.c,v
retrieving revision 1.138
retrieving revision 1.161
diff -u -p -r1.138 -r1.161
--- mandoc/roff.c	2011/05/14 16:06:08	1.138
+++ mandoc/roff.c	2011/07/27 14:58:28	1.161
@@ -1,4 +1,4 @@
-/*	$Id: roff.c,v 1.138 2011/05/14 16:06:08 kristaps Exp $ */
+/*	$Id: roff.c,v 1.161 2011/07/27 14:58:28 kristaps Exp $ */
 /*
  * Copyright (c) 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
@@ -28,6 +28,7 @@
 #include "libroff.h"
 #include "libmandoc.h"
 
+/* Maximum number of nested if-else conditionals. */
 #define	RSTACK_MAX	128
 
 enum	rofft {
@@ -60,7 +61,7 @@ enum	rofft {
 	ROFF_EQ,
 	ROFF_EN,
 	ROFF_cblock,
-	ROFF_ccond, /* FIXME: remove this. */
+	ROFF_ccond,
 	ROFF_USERDEF,
 	ROFF_MAX
 };
@@ -70,9 +71,19 @@ enum	roffrule {
 	ROFFRULE_DENY
 };
 
+/*
+ * A single register entity.  If "set" is zero, the value of the
+ * register should be the default one, which is per-register.
+ * Registers are assumed to be unsigned ints for now.
+ */
+struct	reg {
+	int		  set; /* whether set or not */
+	unsigned int	  u; /* unsigned integer */
+};
+
 struct	roffstr {
-	char		*name; /* key of symbol */
-	char		*string; /* current value */
+	char		*key; /* key of symbol */
+	char		*val; /* current value */
 	struct roffstr	*next; /* next in list */
 };
 
@@ -81,7 +92,7 @@ struct	roff {
 	struct roffnode	*last; /* leaf of stack */
 	enum roffrule	 rstack[RSTACK_MAX]; /* stack of !`ie' rules */
 	int		 rstackpos; /* position in rstack */
-	struct regset	*regs; /* read/writable registers */
+	struct reg	 regs[REG__MAX];
 	struct roffstr	*first_string; /* user-defined strings & macros */
 	const char	*current_string; /* value of last called user macro */
 	struct tbl_node	*first_tbl; /* first table parsed */
@@ -124,6 +135,20 @@ struct	roffmac {
 	struct roffmac	*next;
 };
 
+struct	predef {
+	const char	*name; /* predefined input name */
+	const char	*str; /* replacement symbol */
+};
+
+#define	PREDEF(__name, __str) \
+	{ (__name), (__str) },
+
+static	enum rofft	 roffhash_find(const char *, size_t);
+static	void		 roffhash_init(void);
+static	void		 roffnode_cleanscope(struct roff *);
+static	void		 roffnode_pop(struct roff *);
+static	void		 roffnode_push(struct roff *, enum rofft,
+				const char *, int, int);
 static	enum rofferr	 roff_block(ROFF_ARGS);
 static	enum rofferr	 roff_block_text(ROFF_ARGS);
 static	enum rofferr	 roff_block_sub(ROFF_ARGS);
@@ -134,14 +159,19 @@ static	enum rofferr	 roff_cond_text(ROFF_ARGS);
 static	enum rofferr	 roff_cond_sub(ROFF_ARGS);
 static	enum rofferr	 roff_ds(ROFF_ARGS);
 static	enum roffrule	 roff_evalcond(const char *, int *);
+static	void		 roff_free1(struct roff *);
 static	void		 roff_freestr(struct roff *);
 static	char		*roff_getname(struct roff *, char **, int, int);
 static	const char	*roff_getstrn(const struct roff *, 
 				const char *, size_t);
 static	enum rofferr	 roff_line_ignore(ROFF_ARGS);
 static	enum rofferr	 roff_nr(ROFF_ARGS);
-static	int		 roff_res(struct roff *, 
-				char **, size_t *, int);
+static	void		 roff_openeqn(struct roff *, const char *, 
+				int, int, const char *);
+static	enum rofft	 roff_parse(struct roff *, const char *, int *);
+static	enum rofferr	 roff_parsetext(char *);
+static	void		 roff_res(struct roff *, 
+				char **, size_t *, int, int);
 static	enum rofferr	 roff_rm(ROFF_ARGS);
 static	void		 roff_setstr(struct roff *,
 				const char *, const char *, int);
@@ -153,7 +183,7 @@ static	enum rofferr	 roff_EN(ROFF_ARGS);
 static	enum rofferr	 roff_T_(ROFF_ARGS);
 static	enum rofferr	 roff_userdef(ROFF_ARGS);
 
-/* See roff_hash_find() */
+/* See roffhash_find() */
 
 #define	ASCII_HI	 126
 #define	ASCII_LO	 33
@@ -195,20 +225,17 @@ static	struct roffmac	 roffs[ROFF_MAX] = {
 	{ NULL, roff_userdef, NULL, NULL, 0, NULL },
 };
 
-static	void		 roff_free1(struct roff *);
-static	enum rofft	 roff_hash_find(const char *, size_t);
-static	void		 roff_hash_init(void);
-static	void		 roffnode_cleanscope(struct roff *);
-static	void		 roffnode_push(struct roff *, enum rofft,
-				const char *, int, int);
-static	void		 roffnode_pop(struct roff *);
-static	enum rofft	 roff_parse(struct roff *, const char *, int *);
+/* Array of injected predefined strings. */
+#define	PREDEFS_MAX	 38
+static	const struct predef predefs[PREDEFS_MAX] = {
+#include "predefs.in"
+};
 
-/* See roff_hash_find() */
+/* See roffhash_find() */
 #define	ROFF_HASH(p)	(p[0] - ASCII_LO)
 
 static void
-roff_hash_init(void)
+roffhash_init(void)
 {
 	struct roffmac	 *n;
 	int		  buc, i;
@@ -228,13 +255,12 @@ roff_hash_init(void)
 	}
 }
 
-
 /*
  * Look up a roff token by its name.  Returns ROFF_MAX if no macro by
  * the nil-terminated string name could be found.
  */
 static enum rofft
-roff_hash_find(const char *p, size_t s)
+roffhash_find(const char *p, size_t s)
 {
 	int		 buc;
 	struct roffmac	*n;
@@ -333,8 +359,14 @@ roff_free1(struct roff *r)
 void
 roff_reset(struct roff *r)
 {
+	int		 i;
 
 	roff_free1(r);
+
+	memset(&r->regs, 0, sizeof(struct reg) * REG__MAX);
+
+	for (i = 0; i < PREDEFS_MAX; i++) 
+		roff_setstr(r, predefs[i].name, predefs[i].str, 0);
 }
 
 
@@ -348,28 +380,33 @@ roff_free(struct roff *r)
 
 
 struct roff *
-roff_alloc(struct regset *regs, struct mparse *parse)
+roff_alloc(struct mparse *parse)
 {
 	struct roff	*r;
+	int		 i;
 
 	r = mandoc_calloc(1, sizeof(struct roff));
-	r->regs = regs;
 	r->parse = parse;
 	r->rstackpos = -1;
 	
-	roff_hash_init();
+	roffhash_init();
+
+	for (i = 0; i < PREDEFS_MAX; i++) 
+		roff_setstr(r, predefs[i].name, predefs[i].str, 0);
+
 	return(r);
 }
 
-
 /*
  * Pre-filter each and every line for reserved words (one beginning with
  * `\*', e.g., `\*(ab').  These must be handled before the actual line
  * is processed. 
+ * This also checks the syntax of regular escapes.
  */
-static int
-roff_res(struct roff *r, char **bufp, size_t *szp, int pos)
+static void
+roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos)
 {
+	enum mandoc_esc	 esc;
 	const char	*stesc;	/* start of an escape sequence ('\\') */
 	const char	*stnam;	/* start of the name, after "[(*" */
 	const char	*cp;	/* end of the name, e.g. before ']' */
@@ -378,8 +415,7 @@ roff_res(struct roff *r, char **bufp, size_t *szp, int
 	size_t		 nsz;
 	char		*n;
 
-	/* Search for a leading backslash and save a pointer to it. */
-
+again:
 	cp = *bufp + pos;
 	while (NULL != (cp = strchr(cp, '\\'))) {
 		stesc = cp++;
@@ -391,10 +427,22 @@ roff_res(struct roff *r, char **bufp, size_t *szp, int
 		 */
 
 		if ('\0' == *cp)
-			return(1);
-		if ('*' != *cp++)
-			continue;
+			return;
 
+		if ('*' != *cp) {
+			res = cp;
+			esc = mandoc_escape(&cp, NULL, NULL);
+			if (ESCAPE_ERROR != esc)
+				continue;
+			cp = res;
+			mandoc_msg
+				(MANDOCERR_BADESCAPE, r->parse, 
+				 ln, (int)(stesc - *bufp), NULL);
+			return;
+		}
+
+		cp++;
+
 		/*
 		 * The third character decides the length
 		 * of the name of the string.
@@ -403,7 +451,7 @@ roff_res(struct roff *r, char **bufp, size_t *szp, int
 
 		switch (*cp) {
 		case ('\0'):
-			return(1);
+			return;
 		case ('('):
 			cp++;
 			maxl = 2;
@@ -421,8 +469,13 @@ roff_res(struct roff *r, char **bufp, size_t *szp, int
 		/* Advance to the end of the name. */
 
 		for (i = 0; 0 == maxl || i < maxl; i++, cp++) {
-			if ('\0' == *cp)
-				return(1); /* Error. */
+			if ('\0' == *cp) {
+				mandoc_msg
+					(MANDOCERR_BADESCAPE, 
+					 r->parse, ln, 
+					 (int)(stesc - *bufp), NULL);
+				return;
+			}
 			if (0 == maxl && ']' == *cp)
 				break;
 		}
@@ -435,12 +488,16 @@ roff_res(struct roff *r, char **bufp, size_t *szp, int
 		res = roff_getstrn(r, stnam, (size_t)i);
 
 		if (NULL == res) {
-			cp -= maxl ? 1 : 0;
-			continue;
+			mandoc_msg
+				(MANDOCERR_BADESCAPE, r->parse, 
+				 ln, (int)(stesc - *bufp), NULL);
+			res = "";
 		}
 
 		/* Replace the escape sequence by the string. */
 
+		pos = stesc - *bufp;
+
 		nsz = *szp + strlen(res) + 1;
 		n = mandoc_malloc(nsz);
 
@@ -452,13 +509,58 @@ roff_res(struct roff *r, char **bufp, size_t *szp, int
 
 		*bufp = n;
 		*szp = nsz;
-		return(0);
+		goto again;
 	}
-
-	return(1);
 }
 
+/*
+ * Process text streams: convert all breakable hyphens into ASCII_HYPH.
+ */
+static enum rofferr
+roff_parsetext(char *p)
+{
+	char		 l, r;
+	size_t		 sz;
+	const char	*start;
+	enum mandoc_esc	 esc;
 
+	start = p;
+
+	while ('\0' != *p) {
+		sz = strcspn(p, "-\\");
+		p += sz;
+
+		if ('\0' == *p)
+			break;
+
+		if ('\\' == *p) {
+			/* Skip over escapes. */
+			p++;
+			esc = mandoc_escape
+				((const char **)&p, NULL, NULL);
+			if (ESCAPE_ERROR == esc)
+				break;
+			continue;
+		} else if (p == start) {
+			p++;
+			continue;
+		}
+
+		l = *(p - 1);
+		r = *(p + 1);
+		if ('\\' != l &&
+				'\t' != r && '\t' != l &&
+				' ' != r && ' ' != l &&
+				'-' != r && '-' != l &&
+				! isdigit((unsigned char)l) &&
+				! isdigit((unsigned char)r))
+			*p = ASCII_HYPH;
+		p++;
+	}
+
+	return(ROFF_CONT);
+}
+
 enum rofferr
 roff_parseln(struct roff *r, int ln, char **bufp, 
 		size_t *szp, int pos, int *offs)
@@ -472,8 +574,7 @@ roff_parseln(struct roff *r, int ln, char **bufp, 
 	 * words to fill in.
 	 */
 
-	if (r->first_string && ! roff_res(r, bufp, szp, pos))
-		return(ROFF_REPARSE);
+	roff_res(r, bufp, szp, ln, pos);
 
 	ppos = pos;
 	ctl = mandoc_getcontrol(*bufp, &pos);
@@ -495,18 +596,18 @@ roff_parseln(struct roff *r, int ln, char **bufp, 
 		if (ROFF_CONT != e)
 			return(e);
 		if (r->eqn)
-			return(eqn_read(&r->eqn, ln, *bufp, pos));
+			return(eqn_read(&r->eqn, ln, *bufp, pos, offs));
 		if (r->tbl)
 			return(tbl_read(r->tbl, ln, *bufp, pos));
-		return(ROFF_CONT);
+		return(roff_parsetext(*bufp + pos));
 	} else if ( ! ctl) {
 		if (r->eqn)
-			return(eqn_read(&r->eqn, ln, *bufp, pos));
+			return(eqn_read(&r->eqn, ln, *bufp, pos, offs));
 		if (r->tbl)
 			return(tbl_read(r->tbl, ln, *bufp, pos));
-		return(ROFF_CONT);
+		return(roff_parsetext(*bufp + pos));
 	} else if (r->eqn)
-		return(eqn_read(&r->eqn, ln, *bufp, ppos));
+		return(eqn_read(&r->eqn, ln, *bufp, ppos, offs));
 
 	/*
 	 * If a scope is open, go to the child handler for that macro,
@@ -548,16 +649,14 @@ roff_endparse(struct roff *r)
 
 	if (r->eqn) {
 		mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse, 
-				r->eqn->eqn.line, r->eqn->eqn.pos, NULL);
-		eqn_end(r->eqn);
-		r->eqn = NULL;
+				r->eqn->eqn.ln, r->eqn->eqn.pos, NULL);
+		eqn_end(&r->eqn);
 	}
 
 	if (r->tbl) {
 		mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse, 
 				r->tbl->line, r->tbl->pos, NULL);
-		tbl_end(r->tbl);
-		r->tbl = NULL;
+		tbl_end(&r->tbl);
 	}
 }
 
@@ -572,14 +671,21 @@ roff_parse(struct roff *r, const char *buf, int *pos)
 	size_t		 maclen;
 	enum rofft	 t;
 
-	if ('\0' == buf[*pos] || '"' == buf[*pos])
+	if ('\0' == buf[*pos] || '"' == buf[*pos] || 
+			'\t' == buf[*pos] || ' ' == buf[*pos])
 		return(ROFF_MAX);
 
+	/*
+	 * We stop the macro parse at an escape, tab, space, or nil.
+	 * However, `\}' is also a valid macro, so make sure we don't
+	 * clobber it by seeing the `\' as the end of token.
+	 */
+
 	mac = buf + *pos;
-	maclen = strcspn(mac, " \\\t\0");
+	maclen = strcspn(mac + 1, " \\\t\0") + 1;
 
 	t = (r->current_string = roff_getstrn(r, mac, maclen))
-	    ? ROFF_USERDEF : roff_hash_find(mac, maclen);
+	    ? ROFF_USERDEF : roffhash_find(mac, maclen);
 
 	*pos += (int)maclen;
 
@@ -840,21 +946,44 @@ roff_cond_sub(ROFF_ARGS)
 {
 	enum rofft	 t;
 	enum roffrule	 rr;
+	char		*ep;
 
 	rr = r->last->rule;
+	roffnode_cleanscope(r);
 
-	/* 
-	 * Clean out scope.  If we've closed ourselves, then don't
-	 * continue. 
+	/*
+	 * If the macro is unknown, first check if it contains a closing
+	 * delimiter `\}'.  If it does, close out our scope and return
+	 * the currently-scoped rule (ignore or continue).  Else, drop
+	 * into the currently-scoped rule.
 	 */
 
-	roffnode_cleanscope(r);
-
 	if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos))) {
-		if ('\\' == (*bufp)[pos] && '}' == (*bufp)[pos + 1])
-			return(roff_ccond
-				(r, ROFF_ccond, bufp, szp,
-				 ln, pos, pos + 2, offs));
+		ep = &(*bufp)[pos];
+		for ( ; NULL != (ep = strchr(ep, '\\')); ep++) {
+			ep++;
+			if ('}' != *ep)
+				continue;
+
+			/*
+			 * Make the \} go away.
+			 * This is a little haphazard, as it's not quite
+			 * clear how nroff does this.
+			 * If we're at the end of line, then just chop
+			 * off the \} and resize the buffer.
+			 * If we aren't, then conver it to spaces.
+			 */
+
+			if ('\0' == *(ep + 1)) {
+				*--ep = '\0';
+				*szp -= 2;
+			} else
+				*(ep - 1) = *ep = ' ';
+
+			roff_ccond(r, ROFF_ccond, bufp, szp, 
+					ln, pos, pos + 2, offs);
+			break;
+		}
 		return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
 	}
 
@@ -863,6 +992,7 @@ roff_cond_sub(ROFF_ARGS)
 	 * if they're either structurally required (such as loops and
 	 * conditionals) or a closing macro.
 	 */
+
 	if (ROFFRULE_DENY == rr)
 		if ( ! (ROFFMAC_STRUCT & roffs[t].flags))
 			if (ROFF_ccond != t)
@@ -873,37 +1003,28 @@ roff_cond_sub(ROFF_ARGS)
 				ln, ppos, pos, offs));
 }
 
-
 /* ARGSUSED */
 static enum rofferr
 roff_cond_text(ROFF_ARGS)
 {
-	char		*ep, *st;
+	char		*ep;
 	enum roffrule	 rr;
 
 	rr = r->last->rule;
+	roffnode_cleanscope(r);
 
-	/*
-	 * We display the value of the text if out current evaluation
-	 * scope permits us to do so.
-	 */
-
-	/* FIXME: use roff_ccond? */
-
-	st = &(*bufp)[pos];
-	if (NULL == (ep = strstr(st, "\\}"))) {
-		roffnode_cleanscope(r);
-		return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
+	ep = &(*bufp)[pos];
+	for ( ; NULL != (ep = strchr(ep, '\\')); ep++) {
+		ep++;
+		if ('}' != *ep)
+			continue;
+		*ep = '&';
+		roff_ccond(r, ROFF_ccond, bufp, szp, 
+				ln, pos, pos + 2, offs);
 	}
-
-	if (ep == st || (ep > st && '\\' != *(ep - 1)))
-		roffnode_pop(r);
-
-	roffnode_cleanscope(r);
 	return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
 }
 
-
 static enum roffrule
 roff_evalcond(const char *v, int *pos)
 {
@@ -1058,7 +1179,27 @@ roff_ds(ROFF_ARGS)
 	return(ROFF_IGN);
 }
 
+int
+roff_regisset(const struct roff *r, enum regs reg)
+{
 
+	return(r->regs[(int)reg].set);
+}
+
+unsigned int
+roff_regget(const struct roff *r, enum regs reg)
+{
+
+	return(r->regs[(int)reg].u);
+}
+
+void
+roff_regunset(struct roff *r, enum regs reg)
+{
+
+	r->regs[(int)reg].set = 0;
+}
+
 /* ARGSUSED */
 static enum rofferr
 roff_nr(ROFF_ARGS)
@@ -1066,18 +1207,16 @@ roff_nr(ROFF_ARGS)
 	const char	*key;
 	char		*val;
 	int		 iv;
-	struct reg	*rg;
 
 	val = *bufp + pos;
 	key = roff_getname(r, &val, ln, pos);
-	rg = r->regs->regs;
 
 	if (0 == strcmp(key, "nS")) {
-		rg[(int)REG_nS].set = 1;
-		if ((iv = mandoc_strntou(val, strlen(val), 10)) >= 0)
-			rg[REG_nS].v.u = (unsigned)iv;
+		r->regs[(int)REG_nS].set = 1;
+		if ((iv = mandoc_strntoi(val, strlen(val), 10)) >= 0)
+			r->regs[(int)REG_nS].u = (unsigned)iv;
 		else
-			rg[(int)REG_nS].v.u = 0u;
+			r->regs[(int)REG_nS].u = 0u;
 	}
 
 	return(ROFF_IGN);
@@ -1107,9 +1246,8 @@ roff_TE(ROFF_ARGS)
 	if (NULL == r->tbl)
 		mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
 	else
-		tbl_end(r->tbl);
+		tbl_end(&r->tbl);
 
-	r->tbl = NULL;
 	return(ROFF_IGN);
 }
 
@@ -1126,14 +1264,24 @@ roff_T_(ROFF_ARGS)
 	return(ROFF_IGN);
 }
 
-/* ARGSUSED */
-static enum rofferr
-roff_EQ(ROFF_ARGS)
+#if 0
+static int
+roff_closeeqn(struct roff *r)
 {
-	struct eqn_node	*e;
 
+	return(r->eqn && ROFF_EQN == eqn_end(&r->eqn) ? 1 : 0);
+}
+#endif
+
+static void
+roff_openeqn(struct roff *r, const char *name, int line, 
+		int offs, const char *buf)
+{
+	struct eqn_node *e;
+	int		 poff;
+
 	assert(NULL == r->eqn);
-	e = eqn_alloc(ppos, ln);
+	e = eqn_alloc(name, offs, line, r->parse);
 
 	if (r->last_eqn)
 		r->last_eqn->next = e;
@@ -1141,6 +1289,19 @@ roff_EQ(ROFF_ARGS)
 		r->first_eqn = r->last_eqn = e;
 
 	r->eqn = r->last_eqn = e;
+
+	if (buf) {
+		poff = 0;
+		eqn_read(&r->eqn, line, buf, offs, &poff);
+	}
+}
+
+/* ARGSUSED */
+static enum rofferr
+roff_EQ(ROFF_ARGS)
+{
+
+	roff_openeqn(r, *bufp + pos, ln, ppos, NULL);
 	return(ROFF_IGN);
 }
 
@@ -1161,7 +1322,7 @@ roff_TS(ROFF_ARGS)
 
 	if (r->tbl) {
 		mandoc_msg(MANDOCERR_SCOPEBROKEN, r->parse, ln, ppos, NULL);
-		tbl_end(r->tbl);
+		tbl_end(&r->tbl);
 	}
 
 	t = tbl_alloc(ppos, ln, r->parse);
@@ -1304,20 +1465,20 @@ roff_setstr(struct roff *r, const char *name, const ch
 
 	/* Search for an existing string with the same name. */
 	n = r->first_string;
-	while (n && strcmp(name, n->name))
+	while (n && strcmp(name, n->key))
 		n = n->next;
 
 	if (NULL == n) {
 		/* Create a new string table entry. */
 		n = mandoc_malloc(sizeof(struct roffstr));
-		n->name = mandoc_strdup(name);
-		n->string = NULL;
+		n->key = mandoc_strdup(name);
+		n->val = NULL;
 		n->next = r->first_string;
 		r->first_string = n;
 	} else if (0 == multiline) {
 		/* In multiline mode, append; else replace. */
-		free(n->string);
-		n->string = NULL;
+		free(n->val);
+		n->val = NULL;
 	}
 
 	if (NULL == string)
@@ -1328,17 +1489,17 @@ roff_setstr(struct roff *r, const char *name, const ch
 	 * and one for the terminating '\0'.
 	 */
 	newch = strlen(string) + (multiline ? 2u : 1u);
-	if (NULL == n->string) {
-		n->string = mandoc_malloc(newch);
-		*n->string = '\0';
+	if (NULL == n->val) {
+		n->val = mandoc_malloc(newch);
+		*n->val = '\0';
 		oldch = 0;
 	} else {
-		oldch = strlen(n->string);
-		n->string = mandoc_realloc(n->string, oldch + newch);
+		oldch = strlen(n->val);
+		n->val = mandoc_realloc(n->val, oldch + newch);
 	}
 
 	/* Skip existing content in the destination buffer. */
-	c = n->string + (int)oldch;
+	c = n->val + (int)oldch;
 
 	/* Append new content to the destination buffer. */
 	while (*string) {
@@ -1362,11 +1523,12 @@ roff_getstrn(const struct roff *r, const char *name, s
 {
 	const struct roffstr *n;
 
-	n = r->first_string;
-	while (n && (strncmp(name, n->name, len) || '\0' != n->name[(int)len]))
-		n = n->next;
+	for (n = r->first_string; n; n = n->next)
+		if (0 == strncmp(name, n->key, len) && 
+				'\0' == n->key[(int)len])
+			return(n->val);
 
-	return(n ? n->string : NULL);
+	return(NULL);
 }
 
 static void
@@ -1375,8 +1537,8 @@ roff_freestr(struct roff *r)
 	struct roffstr	 *n, *nn;
 
 	for (n = r->first_string; n; n = nn) {
-		free(n->name);
-		free(n->string);
+		free(n->key);
+		free(n->val);
 		nn = n->next;
 		free(n);
 	}
@@ -1396,4 +1558,11 @@ roff_eqn(const struct roff *r)
 {
 	
 	return(r->last_eqn ? &r->last_eqn->eqn : NULL);
+}
+
+char
+roff_eqndelim(const struct roff *r)
+{
+
+	return('\0');
 }