===================================================================
RCS file: /cvs/mandoc/term.c,v
retrieving revision 1.238
retrieving revision 1.243
diff -u -p -r1.238 -r1.243
--- mandoc/term.c	2014/12/19 17:12:04	1.238
+++ mandoc/term.c	2015/01/21 20:33:25	1.243
@@ -1,7 +1,7 @@
-/*	$Id: term.c,v 1.238 2014/12/19 17:12:04 schwarze Exp $ */
+/*	$Id: term.c,v 1.243 2015/01/21 20:33:25 schwarze Exp $ */
 /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010-2015 Ingo Schwarze <schwarze@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
@@ -101,7 +101,6 @@ term_flushln(struct termp *p)
 	size_t		 j;     /* temporary loop index for p->buf */
 	size_t		 jhy;	/* last hyph before overflow w/r/t j */
 	size_t		 maxvis; /* output position of visible boundary */
-	size_t		 rmargin; /* the rightmost of the two margins */
 
 	/*
 	 * First, establish the maximum columns of "visible" content.
@@ -114,8 +113,7 @@ term_flushln(struct termp *p)
 	 * is negative, it gets sign extended.  Subtracting that
 	 * very large size_t effectively adds a small number to dv.
 	 */
-	rmargin = p->rmargin > p->offset ? p->rmargin : p->offset;
-	dv = p->rmargin - p->offset;
+	dv = p->rmargin > p->offset ? p->rmargin - p->offset : 0;
 	maxvis = (int)dv > p->overstep ? dv - (size_t)p->overstep : 0;
 
 	if (p->flags & TERMP_NOBREAK) {
@@ -193,8 +191,9 @@ term_flushln(struct termp *p)
 			(*p->endline)(p);
 			p->viscol = 0;
 			if (TERMP_BRIND & p->flags) {
-				vbl = rmargin;
-				vend += rmargin - p->offset;
+				vbl = p->rmargin;
+				vend += p->rmargin;
+				vend -= p->offset;
 			} else
 				vbl = p->offset;
 
@@ -274,7 +273,7 @@ term_flushln(struct termp *p)
 	}
 
 	if (TERMP_HANG & p->flags) {
-		p->overstep = (int)(vis - maxvis +
+		p->overstep += (int)(p->offset + vis - p->rmargin +
 		    p->trailspace * (*p->width)(p, ' '));
 
 		/*
@@ -496,6 +495,17 @@ term_word(struct termp *p, const char *word)
 		case ESCAPE_SKIPCHAR:
 			p->flags |= TERMP_SKIPCHAR;
 			continue;
+		case ESCAPE_OVERSTRIKE:
+			cp = seq + sz;
+			while (seq < cp) {
+				if (*seq == '\\') {
+					mandoc_escape(&seq, NULL, NULL);
+					continue;
+				}
+				encode1(p, *seq++);
+				if (seq < cp)
+					encode(p, "\b", 1);
+			}
 		default:
 			continue;
 		}
@@ -717,6 +727,20 @@ term_strlen(const struct termp *p, const char *cp)
 			case ESCAPE_SKIPCHAR:
 				skip = 1;
 				continue;
+			case ESCAPE_OVERSTRIKE:
+				rsz = 0;
+				rhs = seq + ssz;
+				while (seq < rhs) {
+					if (*seq == '\\') {
+						mandoc_escape(&seq, NULL, NULL);
+						continue;
+					}
+					i = (*p->width)(p, *seq++);
+					if (rsz < i)
+						rsz = i;
+				}
+				sz += rsz;
+				continue;
 			default:
 				continue;
 			}
@@ -770,47 +794,55 @@ term_strlen(const struct termp *p, const char *cp)
 	return(sz);
 }
 
-size_t
+int
 term_vspan(const struct termp *p, const struct roffsu *su)
 {
 	double		 r;
+	int		 ri;
 
 	switch (su->unit) {
+	case SCALE_BU:
+		r = su->scale / 40.0;
+		break;
 	case SCALE_CM:
-		r = su->scale * 2.0;
+		r = su->scale * 6.0 / 2.54;
 		break;
+	case SCALE_FS:
+		r = su->scale * 65536.0 / 40.0;
+		break;
 	case SCALE_IN:
 		r = su->scale * 6.0;
 		break;
+	case SCALE_MM:
+		r = su->scale * 0.006;
+		break;
 	case SCALE_PC:
 		r = su->scale;
 		break;
 	case SCALE_PT:
-		r = su->scale / 8.0;
+		r = su->scale / 12.0;
 		break;
-	case SCALE_MM:
-		r = su->scale / 1000.0;
+	case SCALE_EN:
+		/* FALLTHROUGH */
+	case SCALE_EM:
+		r = su->scale * 0.6;
 		break;
 	case SCALE_VS:
 		r = su->scale;
 		break;
 	default:
-		r = su->scale - 1.0;
-		break;
+		abort();
+		/* NOTREACHED */
 	}
-
-	if (r < 0.0)
-		r = 0.0;
-	return((size_t)(r + 0.0005));
+	ri = r > 0.0 ? r + 0.4995 : r - 0.4995;
+	return(ri < 66 ? ri : 1);
 }
 
-size_t
+int
 term_hspan(const struct termp *p, const struct roffsu *su)
 {
 	double		 v;
 
 	v = (*p->hspan)(p, su);
-	if (v < 0.0)
-		v = 0.0;
-	return((size_t)(v + 0.0005));
+	return(v > 0.0 ? v + 0.0005 : v - 0.0005);
 }