jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
swig/Source/Preprocessor/expr.c
Dave Beazley b558974525 First checkin 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@34 626c5289-ae23-0410-ae9c-e8d60b6d4f22
2000-01-11 20:08:25 +00:00

325 lines
8.3 KiB
C
Raw Blame History

/****************************************************************************
* Simplified Wrapper and Interface Generator (SWIG)
*
* Author : David Beazley
*
* Department of Computer Science
* University of Chicago
* 1100 E 58th Street
* Chicago, IL 60637
* beazley@cs.uchicago.edu
*
* Please read the file LICENSE for the copyright and terms by which SWIG
* can be used and distributed.
****************************************************************************/
#include "swigcpp.h"
/* -----------------------------------------------------------------------------
* expr.c
*
* This is your basic ol' integer arithmetic expression evaluator. Could have
* used yacc for this, but it generates something like 1000 lines of code
* (whereas this implementation is much smaller).
*
* This module is primarily for use by the preprocessor and any other parts of
* the compiler that need to perform compile-time expression evaluation.
* ----------------------------------------------------------------------------- */
static Scanner *scan = 0;
typedef struct {
int op;
long value;
} exprval;
#define EXPR_TOP 1
#define EXPR_VALUE 2
#define EXPR_OP 3
#define EXPR_GROUP 4
#define EXPR_UMINUS 100
static exprval stack[256]; /* Parsing stack */
static int sp = 0; /* Stack pointer */
static int prec[256]; /* Precedence rules */
static int expr_init = 0; /* Initialization flag */
static char *errmsg = 0; /* Parsing error */
/* Initialize the precedence table for various operators. Low values have higher precedence */
static void init_precedence() {
prec[TOKEN_NOT] = 10;
prec[EXPR_UMINUS] = 10;
prec[TOKEN_STAR] = 20;
prec[TOKEN_SLASH] = 20;
prec[TOKEN_PERCENT] = 20;
prec[TOKEN_PLUS] = 30;
prec[TOKEN_MINUS] = 30;
prec[TOKEN_LSHIFT] = 40;
prec[TOKEN_RSHIFT] = 40;
prec[TOKEN_AND] = 50;
prec[TOKEN_XOR] = 60;
prec[TOKEN_OR] = 70;
prec[TOKEN_EQUALTO] = 80;
prec[TOKEN_NOTEQUAL] = 80;
prec[TOKEN_LESSTHAN] = 80;
prec[TOKEN_GREATERTHAN] = 80;
prec[TOKEN_LTEQUAL] = 80;
prec[TOKEN_GTEQUAL] = 80;
prec[TOKEN_LNOT] = 90;
prec[TOKEN_LAND] = 100;
prec[TOKEN_LOR] = 110;
expr_init = 1;
}
/* Reduce a single operator on the stack */
static void reduce_op() {
if (stack[sp-1].op != EXPR_OP) {
errmsg = "Missing operator";
sp = 0;
return;
}
switch(stack[sp-1].value) {
case TOKEN_STAR:
stack[sp-2].value = stack[sp-2].value * stack[sp].value;
sp -= 2;
break;
case TOKEN_EQUALTO:
stack[sp-2].value = stack[sp-2].value == stack[sp].value;
sp -= 2;
break;
case TOKEN_NOTEQUAL:
stack[sp-2].value = stack[sp-2].value != stack[sp].value;
sp -= 2;
break;
case TOKEN_PLUS:
stack[sp-2].value = stack[sp-2].value + stack[sp].value;
sp -= 2;
break;
case TOKEN_MINUS:
stack[sp-2].value = stack[sp-2].value - stack[sp].value;
sp -= 2;
break;
case TOKEN_AND:
stack[sp-2].value = stack[sp-2].value & stack[sp].value;
sp -= 2;
break;
case TOKEN_LAND:
stack[sp-2].value = stack[sp-2].value && stack[sp].value;
sp -= 2;
break;
case TOKEN_OR:
stack[sp-2].value = stack[sp-2].value | stack[sp].value;
sp -= 2;
break;
case TOKEN_LOR:
stack[sp-2].value = stack[sp-2].value || stack[sp].value;
sp -= 2;
break;
case TOKEN_XOR:
stack[sp-2].value = stack[sp-2].value ^ stack[sp].value;
sp -= 2;
break;
case TOKEN_LESSTHAN:
stack[sp-2].value = stack[sp-2].value < stack[sp].value;
sp -= 2;
break;
case TOKEN_GREATERTHAN:
stack[sp-2].value = stack[sp-2].value > stack[sp].value;
sp -= 2;
break;
case TOKEN_LTEQUAL:
stack[sp-2].value = stack[sp-2].value <= stack[sp].value;
sp -= 2;
break;
case TOKEN_GTEQUAL:
stack[sp-2].value = stack[sp-2].value >= stack[sp].value;
sp -= 2;
break;
case TOKEN_NOT:
stack[sp-1].value = ~stack[sp].value;
sp--;
break;
case TOKEN_LNOT:
stack[sp-1].value = !stack[sp].value;
sp--;
break;
case EXPR_UMINUS:
stack[sp-1].value = -stack[sp].value;
sp--;
break;
case TOKEN_SLASH:
stack[sp-2].value = stack[sp-2].value / stack[sp].value;
sp -= 2;
break;
case TOKEN_PERCENT:
stack[sp-2].value = stack[sp-2].value % stack[sp].value;
sp -= 2;
break;
case TOKEN_LSHIFT:
stack[sp-2].value = stack[sp-2].value << stack[sp].value;
sp -= 2;
break;
case TOKEN_RSHIFT:
stack[sp-2].value = stack[sp-2].value >> stack[sp].value;
sp -= 2;
break;
default:
errmsg = "Syntax error";
sp = 0;
break;
}
stack[sp].op = EXPR_VALUE;
}
/* -----------------------------------------------------------------------------
* void SWIG_expr_init()
*
* Initialize the expression evaluator
* ----------------------------------------------------------------------------- */
void SWIG_expr_init() {
if (!expr_init) init_precedence();
if (!scan) scan = NewScanner();
}
/* -----------------------------------------------------------------------------
* int SWIG_expr(DOH *s, int *error)
*
* Evaluates an arithmetic expression in s.
* ----------------------------------------------------------------------------- */
int SWIG_expr(DOH *s, int *error) {
int token = 0;
int op = 0;
sp = 0;
assert(s);
assert(scan);
Seek(s,0,SEEK_SET);
*error = 0;
Scanner_clear(scan);
Scanner_push(scan,s);
/* Put initial state onto the stack */
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
while (1) {
/* Look at the top of the stack */
switch(stack[sp].op) {
case EXPR_TOP:
/* An expression. Can be a number or another expression enclosed in parens */
token = Scanner_token(scan);
if (!token) {
errmsg = "Expected an expression";
*error = 1;
return 0;
}
break;
case EXPR_VALUE:
/* A value is on the stack. We may reduce or evaluate depending on what the next token is */
token = Scanner_token(scan);
if (!token) {
/* End of input. Might have to reduce if an operator is on stack */
while (sp > 0) {
if (stack[sp-1].op == EXPR_OP) {
reduce_op();
} else if (stack[sp-1].op == EXPR_GROUP) {
errmsg = "Missing \')\'";
*error = 1;
return 0;
} else goto syntax_error;
}
return stack[sp].value;
}
/* Token must be an operator */
switch(token) {
case TOKEN_STAR:
case TOKEN_EQUALTO:
case TOKEN_NOTEQUAL:
case TOKEN_PLUS:
case TOKEN_MINUS:
case TOKEN_AND:
case TOKEN_LAND:
case TOKEN_OR:
case TOKEN_LOR:
case TOKEN_XOR:
case TOKEN_LESSTHAN:
case TOKEN_GREATERTHAN:
case TOKEN_LTEQUAL:
case TOKEN_GTEQUAL:
case TOKEN_SLASH:
case TOKEN_PERCENT:
case TOKEN_LSHIFT:
case TOKEN_RSHIFT:
if ((sp == 0) || (stack[sp-1].op == EXPR_GROUP)) {
/* No possibility of reduce. Push operator and expression */
sp++;
stack[sp].op = EXPR_OP;
stack[sp].value = token;
sp++;
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
} else {
if (stack[sp-1].op != EXPR_OP) goto syntax_error;
op = stack[sp-1].value; /* Previous operator */
/* Now, depending on the precedence relationship between the last operator and the current
we will reduce or push */
if (prec[op] <= prec[token]) {
/* Reduce the previous operator */
reduce_op();
if (stack[sp].op != EXPR_VALUE) goto syntax_error;
}
sp++;
stack[sp].op = EXPR_OP;
stack[sp].value = token;
sp++;
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
}
break;
case TOKEN_RPAREN:
if (sp == 0) goto extra_rparen;
/* Might have to reduce operators first */
while ((sp > 0) && (stack[sp-1].op == EXPR_OP)) reduce_op();
if ((sp == 0) || (stack[sp-1].op != EXPR_GROUP)) goto extra_rparen;
stack[sp-1].op = EXPR_VALUE;
stack[sp-1].value = stack[sp].value;
sp--;
break;
default:
goto syntax_error;
break;
}
break;
default:
fprintf(stderr,"Internal error in expression evaluator.\n");
abort();
}
}
syntax_error:
errmsg = "Syntax error";
*error = 1;
return 0;
extra_rparen:
errmsg = "Extra \')\'";
*error = 1;
return 0;
}
/* Return the expression error message */
char *SWIG_expr_error() {
return errmsg;
}
Reference in a new issue View git blame Copy permalink