minix/commands/m4/expr.c

588 lines
12 KiB
C
Raw Normal View History

2005-04-21 16:53:53 +02:00
/*
* expression evaluator: performs a standard recursive
* descent parse to evaluate any expression permissible
* within the following grammar:
*
* expr : query EOS
* query : lor
* | lor "?" query ":" query
* lor : land { "||" land }
* land : bor { "&&" bor }
* 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 "'"
* num : decnum
* | "0" octnum
* | "0x" hexnum
* octnum : OCTDIGIT
* | OCTDIGIT octnum
* decnum : DECDIGIT
* | DECDIGIT decnum
* hexnum : HEXDIGIT
* | HEXDIGIT hexnum
* shop : "<<"
* | ">>"
* eqlrel : "="
* | "=="
* | "!="
* rel : "<"
* | ">"
* | "<="
* | ">="
*
*
* This expression evaluator is lifted from a public-domain
* C Pre-Processor included with the DECUS C Compiler distribution.
* It is hacked somewhat to be suitable for m4.
*
* Originally by: Mike Lutz
* Bob Harper
*/
#include "mdef.h"
#define TRUE 1
#define FALSE 0
#define EOS (char) 0
#define EQL 0
#define NEQ 1
#define LSS 2
#define LEQ 3
#define GTR 4
#define GEQ 5
static char *nxtch; /* Parser scan pointer */
/*
* For longjmp
*/
#include <setjmp.h>
static jmp_buf expjump;
/*
* macros:
*
* ungetch - Put back the last character examined.
* getch - return the next character from expr string.
*/
#define ungetch() nxtch--
#define getch() *nxtch++
int expr(expbuf)
char *expbuf;
{
register int rval;
nxtch = expbuf;
if (setjmp(expjump) != 0)
return (FALSE);
rval = query();
if (skipws() == EOS)
return(rval);
experr("Ill-formed expression");
/* NOTREACHED */
return(0);
}
/*
* query : lor | lor '?' query ':' query
*
*/
int query()
{
register int bool, true_val, false_val;
bool = lor();
if (skipws() != '?') {
ungetch();
return(bool);
}
true_val = query();
if (skipws() != ':')
experr("Bad query");
false_val = query();
return(bool ? true_val : false_val);
}
/*
* lor : land { '||' land }
*
*/
int lor()
{
register int c, vl, vr;
vl = land();
while ((c = skipws()) == '|' && getch() == '|') {
vr = land();
vl = vl || vr;
}
if (c == '|')
ungetch();
ungetch();
return(vl);
}
/*
* land : bor { '&&' bor }
*
*/
int land()
{
register int c, vl, vr;
vl = bor();
while ((c = skipws()) == '&' && getch() == '&') {
vr = bor();
vl = vl && vr;
}
if (c == '&')
ungetch();
ungetch();
return(vl);
}
/*
* bor : bxor { '|' bxor }
*
*/
int bor()
{
register int vl, vr, c;
vl = bxor();
while ((c = skipws()) == '|' && getch() != '|') {
ungetch();
vr = bxor();
vl |= vr;
}
if (c == '|')
ungetch();
ungetch();
return(vl);
}
/*
* bxor : band { '^' band }
*
*/
int bxor()
{
register int vl, vr;
vl = band();
while (skipws() == '^') {
vr = band();
vl ^= vr;
}
ungetch();
return(vl);
}
/*
* band : eql { '&' eql }
*
*/
int band()
{
register int vl, vr, c;
vl = eql();
while ((c = skipws()) == '&' && getch() != '&') {
ungetch();
vr = eql();
vl &= vr;
}
if (c == '&')
ungetch();
ungetch();
return(vl);
}
/*
* eql : relat { eqrel relat }
*
*/
int eql()
{
register int vl, vr, rel;
vl = relat();
while ((rel = geteql()) != -1) {
vr = relat();
switch (rel) {
case EQL:
vl = (vl == vr);
break;
case NEQ:
vl = (vl != vr);
break;
}
}
return(vl);
}
/*
* relat : shift { rel shift }
*
*/
int relat()
{
register int vl, vr, rel;
vl = shift();
while ((rel = getrel()) != -1) {
vr = shift();
switch (rel) {
case LEQ:
vl = (vl <= vr);
break;
case LSS:
vl = (vl < vr);
break;
case GTR:
vl = (vl > vr);
break;
case GEQ:
vl = (vl >= vr);
break;
}
}
return(vl);
}
/*
* shift : primary { shop primary }
*
*/
int shift()
{
register int vl, vr, c;
vl = primary();
while (((c = skipws()) == '<' || c == '>') && c == getch()) {
vr = primary();
if (c == '<')
vl <<= vr;
else
vl >>= vr;
}
if (c == '<' || c == '>')
ungetch();
ungetch();
return(vl);
}
/*
* primary : term { addop term }
*
*/
int primary()
{
register int c, vl, vr;
vl = term();
while ((c = skipws()) == '+' || c == '-') {
vr = term();
if (c == '+')
vl += vr;
else
vl -= vr;
}
ungetch();
return(vl);
}
/*
* <term> := <unary> { <mulop> <unary> }
*
*/
int term()
{
register int c, vl, vr;
vl = unary();
while ((c = skipws()) == '*' || c == '/' || c == '%') {
vr = unary();
switch (c) {
case '*':
vl *= vr;
break;
case '/':
vl /= vr;
break;
case '%':
vl %= vr;
break;
}
}
ungetch();
return(vl);
}
/*
* unary : factor | unop unary
*
*/
int unary()
{
register int val, c;
if ((c = skipws()) == '!' || c == '~' || c == '-') {
val = unary();
switch (c) {
case '!':
return(! val);
case '~':
return(~ val);
case '-':
return(- val);
}
}
ungetch();
return(factor());
}
/*
* factor : constant | '(' query ')'
*
*/
int factor()
{
register int val;
if (skipws() == '(') {
val = query();
if (skipws() != ')')
experr("Bad factor");
return(val);
}
ungetch();
return(constant());
}
/*
* constant: num | 'char'
*
*/
int constant()
{
/*
* Note: constant() handles multi-byte constants
*/
register int i;
register int value;
register char c;
int v[sizeof (int)];
if (skipws() != '\'') {
ungetch();
return(num());
}
for (i = 0; i < sizeof(int); i++) {
if ((c = getch()) == '\'') {
ungetch();
break;
}
if (c == '\\') {
switch (c = getch()) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
ungetch();
c = num();
break;
case 'n':
c = 012;
break;
case 'r':
c = 015;
break;
case 't':
c = 011;
break;
case 'b':
c = 010;
break;
case 'f':
c = 014;
break;
}
}
v[i] = c;
}
if (i == 0 || getch() != '\'')
experr("Illegal character constant");
for (value = 0; --i >= 0;) {
value <<= 8;
value += v[i];
}
return(value);
}
/*
* num : digit | num digit
*
*/
int num()
{
register int rval, c, base;
int ndig;
ndig = 0;
if ((c = skipws()) == '0') {
c = getch ();
if (c == 'x' || c == 'X') {
base = 16;
c = getch ();
} else {
base = 8;
ndig = 1;
}
} else {
base = 10;
}
rval = 0;
for (;;) {
if (isdigit(c)) c -= '0';
else if (isupper (c)) c -= ('A' - 10);
else if (islower (c)) c -= ('a' - 10);
else break;
if (c < 0 || c >= base)
break;
rval *= base;
rval += c;
c = getch();
ndig++;
}
ungetch();
if (ndig)
return(rval);
experr("Bad constant");
/* NOTREACHED */
return(0);
}
/*
* eqlrel : '=' | '==' | '!='
*
*/
int geteql()
{
register int c1, c2;
c1 = skipws();
c2 = getch();
switch (c1) {
case '=':
if (c2 != '=')
ungetch();
return(EQL);
case '!':
if (c2 == '=')
return(NEQ);
ungetch();
ungetch();
return(-1);
default:
ungetch();
ungetch();
return(-1);
}
}
/*
* rel : '<' | '>' | '<=' | '>='
*
*/
int getrel()
{
register int c1, c2;
c1 = skipws();
c2 = getch();
switch (c1) {
case '<':
if (c2 == '=')
return(LEQ);
ungetch();
return(LSS);
case '>':
if (c2 == '=')
return(GEQ);
ungetch();
return(GTR);
default:
ungetch();
ungetch();
return(-1);
}
}
/*
* Skip over any white space and return terminating char.
*/
int skipws()
{
register char c;
while ((c = getch()) <= ' ' && c > EOS)
;
return(c);
}
/*
* Error handler - resets environment to eval(), prints an error,
* and returns FALSE.
*/
int experr(msg)
char *msg;
{
printf("mp: %s\n",msg);
longjmp(expjump, -1); /* Force eval() to return FALSE */
}