projects / unix-history / blob
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
This commit was manufactured by cvs2svn to create tag 'FreeBSD-release/1.0'.
[unix-history] / usr.bin / m4 / expr.c
/* File : expr.c
Authors: Mike Lutz & Bob Harper
Editors: Ozan Yigit & Richard A. O'Keefe
Updated: %G%
Purpose: arithmetic expression evaluator.
expr() performs a standard recursive descent parse to evaluate any
expression permitted byf the following grammar:
expr : query EOS
query : lor
| lor "?" query ":" query
lor : land { "||" land } or OR, for Pascal
land : bor { "&&" bor } or AND, for Pascal
bor : bxor { "|" bxor }
bxor : band { "^" band }
band : eql { "&" eql }
eql : relat { eqrel relat }
relat : shift { rel shift }
shift : primary { shop primary }
primary : term { addop term }
term : unary { mulop unary }
unary : factor
| unop unary
factor : constant
| "(" query ")"
constant: num
| "'" CHAR "'" or '"' CHAR '"'
num : DIGIT full ANSI C syntax
| DIGIT num
shop : "<<"
| ">>"
eqlrel : "="
| "=="
| "!="
rel : "<" or <>, Pascal not-equal
| ">"
| "<=" or =<, for Prolog users.
| ">="
This expression evaluator was lifted from a public-domain
C Pre-Processor included with the DECUS C Compiler distribution.
It has been hacked somewhat to be suitable for m4.
26-Mar-1993 Changed to work in any of EBCDIC, ASCII, DEC MNCS,
or ISO 8859/n.
26-Mar-1993 Changed to use "long int" rather than int, so that
we get the same 32-bit arithmetic on a PC as on a Sun.
It isn't fully portable, of course, but then on a 64-
bit machine we _want_ 64-bit arithmetic...
Shifting rewritten (using LONG_BIT) to give signed
shifts even when (long) >> (long) is unsigned.
26-Mar-1993 I finally got sick of the fact that &&, ||, and ?:
don't do conditional evaluation. What is the good
of having eval(0&&(1/0)) crash and dump core? Now
every function has a doit? argument.
26-Mar-1993 charcon() didn't actually accept 'abcd', which it
should have. Fixed it.
20-Apr-1993 eval(1/0) and eval(1%0) dumped core and crashed.
This is also true of the System V r 3.2 m4, but
it isn't good enough for ours! Changed it so that
x % 0 => x as per Concrete Mathematics
x / 0 => error and return 0 from expr().
*/
#define FALSE 0
#define TRUE 1
#include <stdio.h>
#include <setjmp.h>
static jmp_buf expjump; /* Error exit point for expr() */
static unsigned char *nxtchr; /* Parser scan pointer */
#define deblank0 while ((unsigned)(*nxtchr-1) < ' ') nxtchr++
#define deblank1 while ((unsigned)(*++nxtchr - 1) < ' ')
#define deblank2 nxtchr++; deblank1
#include "ourlims.h"
static char digval[1+UCHAR_MAX];
/* This file should work in any C implementation that doesn't have too
many characters to fit in one table. We use a table to convert
(unsigned) characters to numeric codes:
0 to 9 for '0' to '9'
10 to 35 for 'a' to 'z'
10 to 35 for 'A' to 'Z'
36 for '_'
Instead of asking whether tolower(c) == 'a' we ask whether
digval[c] == DIGIT_A, and so on. This essentially duplicates the
chtype[] table in main.c; we should use just one table.
*/
#define DIGIT_A 10
#define DIGIT_B 11
#define DIGIT_C 12
#define DIGIT_D 13
#define DIGIT_E 14
#define DIGIT_F 15
#define DIGIT_G 16
#define DIGIT_H 17
#define DIGIT_I 18
#define DIGIT_J 19
#define DIGIT_K 20
#define DIGIT_L 21
#define DIGIT_M 22
#define DIGIT_N 23
#define DIGIT_O 24
#define DIGIT_P 25
#define DIGIT_Q 26
#define DIGIT_R 27
#define DIGIT_S 28
#define DIGIT_T 29
#define DIGIT_U 30
#define DIGIT_V 31
#define DIGIT_W 32
#define DIGIT_X 33
#define DIGIT_Y 34
#define DIGIT_Z 35
#ifdef __STDC__
static long int query(int);
#else
static long int query();
#endif
/* experr(msg)
prints an error message, resets environment to expr(), and
forces expr() to return FALSE.
*/
void experr(msg)
char *msg;
{
(void) fprintf(stderr, "m4: %s\n", msg);
longjmp(expjump, -1); /* Force expr() to return FALSE */
}
/* <numcon> ::= '0x' <hex> | '0X' <hex> | '0' <oct> | <dec>
For ANSI C, an integer may be followed by u, l, ul, or lu,
in any mix of cases. We accept and ignore those letters;
all the numbers are treated as long.
*/
static long int numcon(doit)
int doit;
{
register long int v; /* current value */
register int b; /* base (radix) */
register int c; /* character or digit value */
if (!doit) {
do nxtchr++; while (digval[*nxtchr] <= 36);
deblank0;
return 0;
}
v = digval[*nxtchr++]; /* We already know it's a digit */
if (v != 0) {
b = 10; /* decimal number */
} else
if (digval[*nxtchr] == DIGIT_X) {
nxtchr++;
b = 16; /* hexadecimal number */
} else {
b = 8; /* octal number */
}
do {
while (digval[c = *nxtchr++] < b) v = v*b + digval[c];
} while (c == '_');
while (digval[c] == DIGIT_L || digval[c] == DIGIT_U) c = *nxtchr++;
nxtchr--; /* unread c */
if ((unsigned)(c-1) < ' ') { deblank1; }
return v;
}
/* <charcon> ::= <qt> { <char> } <qt>
Note: multibyte constants are accepted.
Note: BEL (\a) and ESC (\e) have the same values in EBCDIC and ASCII.
*/
static long int charcon(doit)
int doit;
{
register int i;
long int value;
register int c;
int q;
int v[sizeof value];
q = *nxtchr++; /* the quote character */
for (i = 0; ; i++) {
c = *nxtchr++;
if (c == q) { /* end of literal, or doubled quote */
if (*nxtchr != c) break;
nxtchr++; /* doubled quote stands for one quote */
}
if (i == sizeof value) experr("Unterminated character constant");
if (c == '\\') {
switch (c = *nxtchr++) {
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c -= '0';
if ((unsigned)(*nxtchr - '0') < 8)
c = (c << 3) | (*nxtchr++ - '0');
if ((unsigned)(*nxtchr - '0') < 8)
c = (c << 3) | (*nxtchr++ - '0');
break;
case 'n': case 'N': c = '\n'; break;
case 'r': case 'R': c = '\r'; break;
case 't': case 'T': c = '\t'; break;
case 'b': case 'B': c = '\b'; break;
case 'f': case 'F': c = '\f'; break;
case 'a': case 'A': c = 007; break;
case 'e': case 'E': c = 033; break;
#if ' ' == 64
case 'd': case 'D': c = 045; break; /*EBCDIC DEL */
#else
case 'd': case 'D': c = 127; break; /* ASCII DEL */
#endif
default : break;
}
}
v[i] = c;
}
deblank0;
if (!doit) return 0;
for (value = 0; --i >= 0; ) value = (value << CHAR_BIT) | v[i];
return value;
}
/* <unary> ::= <unop> <unary> | <factor>
<unop> ::= '!' || '~' | '-'
<factor> ::= '(' <query> ')' | <'> <char> <'> | <"> <char> <"> | <num>
*/
static long int unary(doit)
int doit;
{
long int v;
switch (nxtchr[0]) {
case 'n': case 'N':
if (digval[nxtchr[1]] != DIGIT_O
|| digval[nxtchr[2]] != DIGIT_T)
experr("Bad 'not'");
nxtchr += 2;
case '!': deblank1; return !unary(doit);
case '~': deblank1; return ~unary(doit);
case '-': deblank1; return -unary(doit);
case '+': deblank1; return unary(doit);
case '(': deblank1; v = query(doit);
if (nxtchr[0] != ')') experr("Bad factor");
deblank1; return v;
case '\'':
case '\"': return charcon(doit);
case '0': case '1': case '2':
case '3': case '4': case '5':
case '6': case '7': case '8':
case '9': return numcon(doit);
default : experr("Bad constant");
}
return 0; /*NOTREACHED*/
}
/* <term> ::= <unary> { <mulop> <unary> }
<mulop> ::= '*' | '/' || '%'
*/
static long int term(doit)
int doit;
{
register long int vl, vr;
vl = unary(doit);
for (;;)
switch (nxtchr[0]) {
case '*':
deblank1;
vr = unary(doit);
if (doit) vl *= vr;
break;
case 'd': case 'D':
if (digval[nxtchr[1]] != DIGIT_I
|| digval[nxtchr[2]] != DIGIT_V)
experr("Bad 'div'");
nxtchr += 2;
/*FALLTHROUGH*/
case '/':
deblank1;
vr = unary(doit);
if (doit) {
if (vr == 0) experr("Division by 0");
vl /= vr;
}
break;
case 'm': case 'M':
if (digval[nxtchr[1]] != DIGIT_O
|| digval[nxtchr[2]] != DIGIT_D)
experr("Bad 'mod'");
nxtchr += 2;
/*FALLTHROUGH*/
case '%':
deblank1;
vr = unary(doit);
if (doit) {
if (vr != 0) vl %= vr;
}
break;
default:
return vl;
}
/*NOTREACHED*/
}
/* <primary> ::= <term> { <addop> <term> }
<addop> ::= '+' | '-'
*/
static long int primary(doit)
int doit;
{
register long int vl;
vl = term(doit);
for (;;)
if (nxtchr[0] == '+') {
deblank1;
if (doit) vl += term(doit); else (void)term(doit);
} else
if (nxtchr[0] == '-') {
deblank1;
if (doit) vl -= term(doit); else (void)term(doit);
} else
return vl;
/*NOTREACHED*/
}
/* <shift> ::= <primary> { <shop> <primary> }
<shop> ::= '<<' | '>>'
*/
static long int shift(doit)
int doit;
{
register long int vl, vr;
vl = primary(doit);
for (;;) {
if (nxtchr[0] == '<' && nxtchr[1] == '<') {
deblank2;
vr = primary(doit);
} else
if (nxtchr[0] == '>' && nxtchr[1] == '>') {
deblank2;
vr = -primary(doit);
} else {
return vl;
}
/* The following code implements shifts portably */
/* Shifts are signed shifts, and the shift count */
/* acts like repeated one-bit shifts, not modulo anything */
if (doit) {
if (vr >= LONG_BIT) {
vl = 0;
} else
if (vr <= -LONG_BIT) {
vl = -(vl < 0);
} else
if (vr > 0) {
vl <<= vr;
} else
if (vr < 0) {
vl = (vl >> -vr) | (-(vl < 0) << (LONG_BIT + vr));
}
}
}
/*NOTREACHED*/
}
/* <relat> ::= <shift> { <rel> <shift> }
<rel> ::= '<=' | '>=' | '=<' | '=>' | '<' | '>'
Here I rely on the fact that '<<' and '>>' are swallowed by <shift>
*/
static long int relat(doit)
int doit;
{
register long int vl;
vl = shift(doit);
for (;;)
switch (nxtchr[0]) {
case '=':
switch (nxtchr[1]) {
case '<': /* =<, take as <= */
deblank2;
vl = vl <= shift(doit);
break;
case '>': /* =>, take as >= */
deblank2;
vl = vl >= shift(doit);
break;
default: /* == or =; OOPS */
return vl;
}
break;
case '<':
if (nxtchr[1] == '=') { /* <= */
deblank2;
vl = vl <= shift(doit);
} else
if (nxtchr[1] == '>') { /* <> (Pascal) */
deblank2;
vl = vl != shift(doit);
} else { /* < */
deblank1;
vl = vl < shift(doit);
}
break;
case '>':
if (nxtchr[1] == '=') { /* >= */
deblank2;
vl = vl >= shift(doit);
} else { /* > */
deblank1;
vl = vl > shift(doit);
}
break;
default:
return vl;
}
/*NOTREACHED*/
}
/* <eql> ::= <relat> { <eqrel> <relat> }
<eqlrel> ::= '!=' | '==' | '='
*/
static long int eql(doit)
int doit;
{
register long int vl;
vl = relat(doit);
for (;;)
if (nxtchr[0] == '!' && nxtchr[1] == '=') {
deblank2;
vl = vl != relat(doit);
} else
if (nxtchr[0] == '=' && nxtchr[1] == '=') {
deblank2;
vl = vl == relat(doit);
} else
if (nxtchr[0] == '=') {
deblank1;
vl = vl == relat(doit);
} else
return vl;
/*NOTREACHED*/
}
/* <band> ::= <eql> { '&' <eql> }
*/
static long int band(doit)
int doit;
{
register long int vl;
vl = eql(doit);
while (nxtchr[0] == '&' && nxtchr[1] != '&') {
deblank1;
if (doit) vl &= eql(doit); else (void)eql(doit);
}
return vl;
}
/* <bxor> ::= <band> { '^' <band> }
*/
static long int bxor(doit)
int doit;
{
register long int vl;
vl = band(doit);
while (nxtchr[0] == '^') {
deblank1;
if (doit) vl ^= band(doit); else (void)band(doit);
}
return vl;
}
/* <bor> ::= <bxor> { '|' <bxor> }
*/
static long int bor(doit)
int doit;
{
register long int vl;
vl = bxor(doit);
while (nxtchr[0] == '|' && nxtchr[1] != '|') {
deblank1;
if (doit) vl |= bxor(doit); else (void)bxor(doit);
}
return vl;
}
/* <land> ::= <bor> { '&&' <bor> }
*/
static long int land(doit)
int doit;
{
register long int vl;
vl = bor(doit);
for (;;) {
if (nxtchr[0] == '&') {
if (nxtchr[1] != '&') break;
deblank2;
} else
if (digval[nxtchr[0]] == DIGIT_A) {
if (digval[nxtchr[1]] != DIGIT_N) break;
if (digval[nxtchr[2]] != DIGIT_D) break;
nxtchr += 2; deblank1;
} else {
/* neither && nor and */
break;
}
vl = bor(doit && vl) != 0;
}
return vl;
}
/* <lor> ::= <land> { '||' <land> }
*/
static long int lor(doit)
int doit;
{
register long int vl;
vl = land(doit);
for (;;) {
if (nxtchr[0] == '|') {
if (nxtchr[1] != '|') break;
} else
if (digval[nxtchr[0]] == DIGIT_O) {
if (digval[nxtchr[1]] != DIGIT_R) break;
} else {
/* neither || nor or */
break;
}
deblank2;
vl = land(doit && !vl) != 0;
}
return vl;
}
/* <query> ::= <lor> [ '?' <query> ':' <query> ]
*/
static long int query(doit)
int doit;
{
register long int bool, true_val, false_val;
bool = lor(doit);
if (*nxtchr != '?') return bool;
deblank1;
true_val = query(doit && bool);
if (*nxtchr != ':') experr("Bad query");
deblank1;
false_val = query(doit && !bool);
return bool ? true_val : false_val;
}
static void initialise_digval()
{
register unsigned char *s;
register int c;
for (c = 0; c <= UCHAR_MAX; c++) digval[c] = 99;
for (c = 0, s = (unsigned char *)"0123456789";
/*while*/ *s;
/*doing*/ digval[*s++] = c++) /* skip */;
for (c = 10, s = (unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
/*while*/ *s;
/*doing*/ digval[*s++] = c++) /* skip */;
for (c = 10, s = (unsigned char *)"abcdefghijklmnopqrstuvwxyz";
/*while*/ *s;
/*doing*/ digval[*s++] = c++) /* skip */;
digval['_'] = 36;
}
long int expr(expbuf)
char *expbuf;
{
register int rval;
if (digval['1'] == 0) initialise_digval();
nxtchr = (unsigned char *)expbuf;
deblank0;
if (setjmp(expjump) != 0) return FALSE;
rval = query(TRUE);
if (*nxtchr) experr("Ill-formed expression");
return rval;
}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.