From 32f5c6ab78d5b0296d7e47d3152101492327e36e Mon Sep 17 00:00:00 2001 From: Ingo Schwarze Date: Mon, 7 Apr 2014 15:07:13 +0000 Subject: 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(). --- roff.7 | 95 ++++++++++++++++++++---- roff.c | 264 +++++++++++++++++++++++++++++++++++++++++++++++++++-------------- 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 ? +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); } -- cgit