Almost complete implementation of roff(7) numerical expressions.

Support all binary operators except ';' (scale conversion).
Fully support chained operations and nested parentheses.
Use this for the .nr, .if, and .ie requests.
While here, fix parsing of integer numbers in roff_getnum().

2 files changed, 286 insertions, 73 deletions

diff --git a/roff.7 b/roff.7
index 5009c8d0..6c5b6cb1 100644
--- a/roff.7
+++ b/roff.7
@@ -751,18 +751,12 @@ or
 .Pq troff mode ,
 COND evaluates to false.
 .It
-If COND starts with a digit, optionally prefixed by a minus sign,
-it is evaluated as a numerical expression of the form
-.Ar number operator number ,
-where
-.Ar operator
-is one of
-.Sq < ,
-.Sq <= ,
-.Sq = ,
-.Sq >= ,
-or
-.Sq > .
+If COND starts with a parenthesis or with an optionally signed
+integer number, it is evaluated according to the rules of
+.Sx Numerical expressions
+explained below.
+It evaluates to true if the the result is positive,
+or to false if the result is zero or negative.
 .It
 Otherwise, the first character of COND is regarded as a delimiter
 and COND evaluates to true if the string extending from its first
@@ -904,11 +898,13 @@ A register is an arbitrary string value that defines some sort of state,
 which influences parsing and/or formatting.
 Its syntax is as follows:
 .Pp
-.D1 Pf \. Cm \&nr Ar name Oo +|- Oc Ns Ar value
+.D1 Pf \. Cm \&nr Ar name Oo +|- Oc Ns Ar expression
 .Pp
-The
-.Ar value
-may, at the moment, only be an integer.
+For the syntax of
+.Ar expression ,
+see
+.Sx Numerical expressions
+below.
 If it is prefixed by a sign, the register will be
 incremented or decremented instead of assigned to.
 .Pp
@@ -1021,6 +1017,73 @@ Begin a table, which formats input in aligned rows and columns.
 See
 .Xr tbl 7
 for a description of the tbl language.
+.Ss Numerical expressions
+The
+.Sx \&nr ,
+.Sx \&if ,
+and
+.Sx \&ie
+requests accept integer numerical expressions as arguments.
+These are always evaluated using the C
+.Vt int
+type; integer overflow works the same way as in the C language.
+Numbers consist of an arbitrary number of digits
+.Sq 0
+to
+.Sq 9
+prefixed by an optional sign
+.Sq +
+or
+.Sq - .
+.Pp
+The following binary operators are implemented.
+Unless otherwise stated, they behave as in the C language:
+.Pp
+.Bl -tag -width 2n -compact
+.It Ic +
+addition
+.It Ic -
+subtraction
+.It Ic *
+multiplication
+.It Ic /
+division
+.It Ic %
+remainder of division
+.It Ic <
+less than
+.It Ic >
+greater than
+.It Ic ==
+equal to
+.It Ic =
+equal to, same effect as
+.Ic ==
+(this differs from C)
+.It Ic <=
+less than or equal to
+.It Ic >=
+greater than or equal to
+.It Ic <>
+not equal to (corresponds to C
+.Ic != ;
+this one is of limited portability, it is supported by Heirloom roff,
+but not by groff)
+.It Ic &
+logical and (corresponds to C
+.Ic && )
+.It Ic \&:
+logical or (corresponds to C
+.Ic \&|| )
+.It Ic <?
+minimum (not available in C)
+.It Ic >?
+maximum (not available in C)
+.El
+.Pp
+There is no concept of precendence; evaluation proceeds from left to right,
+except when subexpressions are enclosed in parantheses.
+Inside parentheses, whitespace is ignored.
 .Sh ESCAPE SEQUENCE REFERENCE
 The
 .Xr mandoc 1
diff --git a/roff.c b/roff.c
index 5890677a..f442fce5 100644
--- a/roff.c
+++ b/roff.c
@@ -181,6 +181,8 @@ static	enum rofferr	 roff_cond_text(ROFF_ARGS);
 static	enum rofferr	 roff_cond_sub(ROFF_ARGS);
 static	enum rofferr	 roff_ds(ROFF_ARGS);
 static	int		 roff_evalcond(const char *, int *);
+static	int		 roff_evalnum(const char *, int *, int *, int);
+static	int		 roff_evalpar(const char *, int *, int *);
 static	int		 roff_evalstrcond(const char *, int *);
 static	void		 roff_free1(struct roff *);
 static	void		 roff_freereg(struct roffreg *);
@@ -1107,6 +1109,12 @@ roff_cond_text(ROFF_ARGS)
 	return(rr ? ROFF_CONT : ROFF_IGN);
 }
 
+/*
+ * Parse a single signed integer number.  Stop at the first non-digit.
+ * If there is at least one digit, return success and advance the
+ * parse point, else return failure and let the parse point unchanged.
+ * Ignore overflows, treat them just like the C language.
+ */
 static int
 roff_getnum(const char *v, int *pos, int *res)
 {
@@ -1118,7 +1126,7 @@ roff_getnum(const char *v, int *pos, int *res)
 		p++;
 
 	for (*res = 0; isdigit((unsigned char)v[p]); p++)
-		*res += 10 * *res + v[p] - '0';
+		*res = 10 * *res + v[p] - '0';
 	if (p == *pos + n)
 		return 0;
 
@@ -1129,34 +1137,6 @@ roff_getnum(const char *v, int *pos, int *res)
 	return 1;
 }
 
-static int
-roff_getop(const char *v, int *pos, char *res)
-{
-	int e;
-
-	*res = v[*pos];
-	e = v[*pos + 1] == '=';
-
-	switch (*res) {
-	case '=':
-		break;
-	case '>':
-		if (e)
-			*res = 'g';
-		break;
-	case '<':
-		if (e)
-			*res = 'l';
-		break;
-	default:
-		return(0);
-	}
-
-	*pos += 1 + e;
-
-	return(*res);
-}
-
 /*
  * Evaluate a string comparison condition.
  * The first character is the delimiter.
@@ -1200,11 +1180,14 @@ out:
 	return(match);
 }
 
+/*
+ * Evaluate an optionally negated single character, numerical,
+ * or string condition.
+ */
 static int
 roff_evalcond(const char *v, int *pos)
 {
-	int	 wanttrue, lh, rh;
-	char	 op;
+	int	 wanttrue, number;
 
 	if ('!' == v[*pos]) {
 		wanttrue = 0;
@@ -1233,27 +1216,10 @@ roff_evalcond(const char *v, int *pos)
 		break;
 	}
 
-	if (!roff_getnum(v, pos, &lh))
+	if (roff_evalnum(v, pos, &number, 0))
+		return((number > 0) == wanttrue);
+	else
 		return(roff_evalstrcond(v, pos) == wanttrue);
-	if (!roff_getop(v, pos, &op))
-		return((lh > 0) == wanttrue);
-	if (!roff_getnum(v, pos, &rh))
-		return(0);
-
-	switch (op) {
-	case 'g':
-		return((lh >= rh) == wanttrue);
-	case 'l':
-		return((lh <= rh) == wanttrue);
-	case '=':
-		return((lh == rh) == wanttrue);
-	case '>':
-		return((lh > rh) == wanttrue);
-	case '<':
-		return((lh < rh) == wanttrue);
-	default:
-		return(0);
-	}
 }
 
 /* ARGSUSED */
@@ -1371,6 +1337,194 @@ roff_ds(ROFF_ARGS)
 	return(ROFF_IGN);
 }
 
+/*
+ * Parse a single operator, one or two characters long.
+ * If the operator is recognized, return success and advance the
+ * parse point, else return failure and let the parse point unchanged.
+ */
+static int
+roff_getop(const char *v, int *pos, char *res)
+{
+
+	*res = v[*pos];
+
+	switch (*res) {
+	case ('+'):
+		/* FALLTHROUGH */
+	case ('-'):
+		/* FALLTHROUGH */
+	case ('*'):
+		/* FALLTHROUGH */
+	case ('/'):
+		/* FALLTHROUGH */
+	case ('%'):
+		/* FALLTHROUGH */
+	case ('&'):
+		/* FALLTHROUGH */
+	case (':'):
+		break;
+	case '<':
+		switch (v[*pos + 1]) {
+		case ('='):
+			*res = 'l';
+			(*pos)++;
+			break;
+		case ('>'):
+			*res = '!';
+			(*pos)++;
+			break;
+		case ('?'):
+			*res = 'i';
+			(*pos)++;
+			break;
+		default:
+			break;
+		}
+		break;
+	case '>':
+		switch (v[*pos + 1]) {
+		case ('='):
+			*res = 'g';
+			(*pos)++;
+			break;
+		case ('?'):
+			*res = 'a';
+			(*pos)++;
+			break;
+		default:
+			break;
+		}
+		break;
+	case '=':
+		if ('=' == v[*pos + 1])
+			(*pos)++;
+		break;
+	default:
+		return(0);
+	}
+	(*pos)++;
+
+	return(*res);
+}
+
+/*
+ * Evaluate either a parenthesized numeric expression
+ * or a single signed integer number.
+ */
+static int
+roff_evalpar(const char *v, int *pos, int *res)
+{
+
+	if ('(' != v[*pos])
+		return(roff_getnum(v, pos, res));
+
+	(*pos)++;
+	if ( ! roff_evalnum(v, pos, res, 1))
+		return(0);
+
+	/* If the trailing parenthesis is missing, ignore the error. */
+	if (')' == v[*pos])
+		(*pos)++;
+
+	return(1);
+}
+
+/*
+ * Evaluate a complete numeric expression.
+ * Proceed left to right, there is no concept of precedence.
+ */
+static int
+roff_evalnum(const char *v, int *pos, int *res, int skipwhite)
+{
+	int		 mypos, operand2;
+	char		 operator;
+
+	if (NULL == pos) {
+		mypos = 0;
+		pos = &mypos;
+	}
+
+	if (skipwhite)
+		while (isspace((unsigned char)v[*pos]))
+			(*pos)++;
+
+	if ( ! roff_evalpar(v, pos, res))
+		return(0);
+
+	while (1) {
+		if (skipwhite)
+			while (isspace((unsigned char)v[*pos]))
+				(*pos)++;
+
+		if ( ! roff_getop(v, pos, &operator))
+			break;
+
+		if (skipwhite)
+			while (isspace((unsigned char)v[*pos]))
+				(*pos)++;
+
+		if ( ! roff_evalpar(v, pos, &operand2))
+			return(0);
+
+		if (skipwhite)
+			while (isspace((unsigned char)v[*pos]))
+				(*pos)++;
+
+		switch (operator) {
+		case ('+'):
+			*res += operand2;
+			break;
+		case ('-'):
+			*res -= operand2;
+			break;
+		case ('*'):
+			*res *= operand2;
+			break;
+		case ('/'):
+			*res /= operand2;
+			break;
+		case ('%'):
+			*res %= operand2;
+			break;
+		case ('<'):
+			*res = *res < operand2;
+			break;
+		case ('>'):
+			*res = *res > operand2;
+			break;
+		case ('l'):
+			*res = *res <= operand2;
+			break;
+		case ('g'):
+			*res = *res >= operand2;
+			break;
+		case ('='):
+			*res = *res == operand2;
+			break;
+		case ('!'):
+			*res = *res != operand2;
+			break;
+		case ('&'):
+			*res = *res && operand2;
+			break;
+		case (':'):
+			*res = *res || operand2;
+			break;
+		case ('i'):
+			if (operand2 < *res)
+				*res = operand2;
+			break;
+		case ('a'):
+			if (operand2 > *res)
+				*res = operand2;
+			break;
+		default:
+			abort();
+		}
+	}
+	return(1);
+}
+
 void
 roff_setreg(struct roff *r, const char *name, int val, char sign)
 {
@@ -1480,13 +1634,11 @@ roff_freereg(struct roffreg *reg)
 	}
 }
 
-/* ARGSUSED */
 static enum rofferr
 roff_nr(ROFF_ARGS)
 {
 	const char	*key;
 	char		*val;
-	size_t		 sz;
 	int		 iv;
 	char		 sign;
 
@@ -1497,10 +1649,8 @@ roff_nr(ROFF_ARGS)
 	if ('+' == sign || '-' == sign)
 		val++;
 
-	sz = strspn(val, "0123456789");
-	iv = sz ? mandoc_strntoi(val, sz, 10) : 0;
-
-	roff_setreg(r, key, iv, sign);
+	if (roff_evalnum(val, NULL, &iv, 0))
+		roff_setreg(r, key, iv, sign);
 
 	return(ROFF_IGN);
 }