jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Renamining

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@102 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-01-18 21:53:32 +00:00
commit cc85906a83
3 changed files with 124 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

156
Source/Preprocessor/expr.c
View file

@ -13,7 +13,7 @@
* can be used and distributed.
****************************************************************************/
#include "swigcore.h"
#include "preprocessor.h"
/* -----------------------------------------------------------------------------
* expr.c
@ -26,7 +26,7 @@
* the compiler that need to perform compile-time expression evaluation.
* ----------------------------------------------------------------------------- */
static Scanner *scan = 0;
static SwigScanner *scan = 0;
typedef struct {
int op;
@ -47,27 +47,27 @@ 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[SWIG_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;
prec[SWIG_TOKEN_STAR] = 20;
prec[SWIG_TOKEN_SLASH] = 20;
prec[SWIG_TOKEN_PERCENT] = 20;
prec[SWIG_TOKEN_PLUS] = 30;
prec[SWIG_TOKEN_MINUS] = 30;
prec[SWIG_TOKEN_LSHIFT] = 40;
prec[SWIG_TOKEN_RSHIFT] = 40;
prec[SWIG_TOKEN_AND] = 50;
prec[SWIG_TOKEN_XOR] = 60;
prec[SWIG_TOKEN_OR] = 70;
prec[SWIG_TOKEN_EQUALTO] = 80;
prec[SWIG_TOKEN_NOTEQUAL] = 80;
prec[SWIG_TOKEN_LESSTHAN] = 80;
prec[SWIG_TOKEN_GREATERTHAN] = 80;
prec[SWIG_TOKEN_LTEQUAL] = 80;
prec[SWIG_TOKEN_GTEQUAL] = 80;
prec[SWIG_TOKEN_LNOT] = 90;
prec[SWIG_TOKEN_LAND] = 100;
prec[SWIG_TOKEN_LOR] = 110;
expr_init = 1;
}
@ -79,67 +79,67 @@ static void reduce_op() {
return;
}
switch(stack[sp-1].value) {
case TOKEN_STAR:
case SWIG_TOKEN_STAR:
stack[sp-2].value = stack[sp-2].value * stack[sp].value;
sp -= 2;
break;
case TOKEN_EQUALTO:
case SWIG_TOKEN_EQUALTO:
stack[sp-2].value = stack[sp-2].value == stack[sp].value;
sp -= 2;
break;
case TOKEN_NOTEQUAL:
case SWIG_TOKEN_NOTEQUAL:
stack[sp-2].value = stack[sp-2].value != stack[sp].value;
sp -= 2;
break;
case TOKEN_PLUS:
case SWIG_TOKEN_PLUS:
stack[sp-2].value = stack[sp-2].value + stack[sp].value;
sp -= 2;
break;
case TOKEN_MINUS:
case SWIG_TOKEN_MINUS:
stack[sp-2].value = stack[sp-2].value - stack[sp].value;
sp -= 2;
break;
case TOKEN_AND:
case SWIG_TOKEN_AND:
stack[sp-2].value = stack[sp-2].value & stack[sp].value;
sp -= 2;
break;
case TOKEN_LAND:
case SWIG_TOKEN_LAND:
stack[sp-2].value = stack[sp-2].value && stack[sp].value;
sp -= 2;
break;
case TOKEN_OR:
case SWIG_TOKEN_OR:
stack[sp-2].value = stack[sp-2].value | stack[sp].value;
sp -= 2;
break;
case TOKEN_LOR:
case SWIG_TOKEN_LOR:
stack[sp-2].value = stack[sp-2].value || stack[sp].value;
sp -= 2;
break;
case TOKEN_XOR:
case SWIG_TOKEN_XOR:
stack[sp-2].value = stack[sp-2].value ^ stack[sp].value;
sp -= 2;
break;
case TOKEN_LESSTHAN:
case SWIG_TOKEN_LESSTHAN:
stack[sp-2].value = stack[sp-2].value < stack[sp].value;
sp -= 2;
break;
case TOKEN_GREATERTHAN:
case SWIG_TOKEN_GREATERTHAN:
stack[sp-2].value = stack[sp-2].value > stack[sp].value;
sp -= 2;
break;
case TOKEN_LTEQUAL:
case SWIG_TOKEN_LTEQUAL:
stack[sp-2].value = stack[sp-2].value <= stack[sp].value;
sp -= 2;
break;
case TOKEN_GTEQUAL:
case SWIG_TOKEN_GTEQUAL:
stack[sp-2].value = stack[sp-2].value >= stack[sp].value;
sp -= 2;
break;
case TOKEN_NOT:
case SWIG_TOKEN_NOT:
stack[sp-1].value = ~stack[sp].value;
sp--;
break;
case TOKEN_LNOT:
case SWIG_TOKEN_LNOT:
stack[sp-1].value = !stack[sp].value;
sp--;
break;
@ -147,19 +147,19 @@ static void reduce_op() {
stack[sp-1].value = -stack[sp].value;
sp--;
break;
case TOKEN_SLASH:
case SWIG_TOKEN_SLASH:
stack[sp-2].value = stack[sp-2].value / stack[sp].value;
sp -= 2;
break;
case TOKEN_PERCENT:
case SWIG_TOKEN_PERCENT:
stack[sp-2].value = stack[sp-2].value % stack[sp].value;
sp -= 2;
break;
case TOKEN_LSHIFT:
case SWIG_TOKEN_LSHIFT:
stack[sp-2].value = stack[sp-2].value << stack[sp].value;
sp -= 2;
break;
case TOKEN_RSHIFT:
case SWIG_TOKEN_RSHIFT:
stack[sp-2].value = stack[sp-2].value >> stack[sp].value;
sp -= 2;
break;
@ -172,23 +172,23 @@ static void reduce_op() {
}
/* -----------------------------------------------------------------------------
* void SWIG_expr_init()
* void Preprocessor_expr_init()
*
* Initialize the expression evaluator
* ----------------------------------------------------------------------------- */
void SWIG_expr_init() {
void Preprocessor_expr_init() {
if (!expr_init) init_precedence();
if (!scan) scan = NewScanner();
if (!scan) scan = NewSwigScanner();
}
/* -----------------------------------------------------------------------------
* int SWIG_expr(DOH *s, int *error)
* int Preprocessor_expr(DOH *s, int *error)
*
* Evaluates an arithmetic expression in s.
* ----------------------------------------------------------------------------- */
int SWIG_expr(DOH *s, int *error) {
int Preprocessor_expr(DOH *s, int *error) {
int token = 0;
int op = 0;
@ -198,8 +198,8 @@ int SWIG_expr(DOH *s, int *error) {
Seek(s,0,SEEK_SET);
*error = 0;
Scanner_clear(scan);
Scanner_push(scan,s);
SwigScanner_clear(scan);
SwigScanner_push(scan,s);
/* Put initial state onto the stack */
stack[sp].op = EXPR_TOP;
@ -210,32 +210,32 @@ int SWIG_expr(DOH *s, int *error) {
switch(stack[sp].op) {
case EXPR_TOP:
/* An expression. Can be a number or another expression enclosed in parens */
token = Scanner_token(scan);
token = SwigScanner_token(scan);
if (!token) {
errmsg = "Expected an expression";
*error = 1;
return 0;
}
if ((token == TOKEN_INT) || (token == TOKEN_UINT) || (token == TOKEN_LONG) || (token == TOKEN_ULONG)) {
if ((token == SWIG_TOKEN_INT) || (token == SWIG_TOKEN_UINT) || (token == SWIG_TOKEN_LONG) || (token == SWIG_TOKEN_ULONG)) {
/* A number. Reduce EXPR_TOP to an EXPR_VALUE */
stack[sp].value = (long) atol(Char(Scanner_text(scan)));
stack[sp].value = (long) atol(Char(SwigScanner_text(scan)));
stack[sp].op = EXPR_VALUE;
} else if (token == TOKEN_PLUS) { }
else if ((token == TOKEN_MINUS) || (token == TOKEN_LNOT) || (token==TOKEN_NOT)) {
if (token == TOKEN_MINUS) token = EXPR_UMINUS;
} else if (token == SWIG_TOKEN_PLUS) { }
else if ((token == SWIG_TOKEN_MINUS) || (token == SWIG_TOKEN_LNOT) || (token==SWIG_TOKEN_NOT)) {
if (token == SWIG_TOKEN_MINUS) token = EXPR_UMINUS;
stack[sp].value = token;
stack[sp++].op = EXPR_OP;
stack[sp].op = EXPR_TOP;
} else if ((token == TOKEN_LPAREN)) {
} else if ((token == SWIG_TOKEN_LPAREN)) {
stack[sp++].op = EXPR_GROUP;
stack[sp].op = EXPR_TOP;
stack[sp].value = 0;
} else if (token == TOKEN_ENDLINE) { }
} else if (token == SWIG_TOKEN_ENDLINE) { }
else goto syntax_error;
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);
token = SwigScanner_token(scan);
if (!token) {
/* End of input. Might have to reduce if an operator is on stack */
while (sp > 0) {
@ -251,24 +251,24 @@ int SWIG_expr(DOH *s, int *error) {
}
/* 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:
case SWIG_TOKEN_STAR:
case SWIG_TOKEN_EQUALTO:
case SWIG_TOKEN_NOTEQUAL:
case SWIG_TOKEN_PLUS:
case SWIG_TOKEN_MINUS:
case SWIG_TOKEN_AND:
case SWIG_TOKEN_LAND:
case SWIG_TOKEN_OR:
case SWIG_TOKEN_LOR:
case SWIG_TOKEN_XOR:
case SWIG_TOKEN_LESSTHAN:
case SWIG_TOKEN_GREATERTHAN:
case SWIG_TOKEN_LTEQUAL:
case SWIG_TOKEN_GTEQUAL:
case SWIG_TOKEN_SLASH:
case SWIG_TOKEN_PERCENT:
case SWIG_TOKEN_LSHIFT:
case SWIG_TOKEN_RSHIFT:
if ((sp == 0) || (stack[sp-1].op == EXPR_GROUP)) {
/* No possibility of reduce. Push operator and expression */
sp++;
@ -297,7 +297,7 @@ int SWIG_expr(DOH *s, int *error) {
stack[sp].value = 0;
}
break;
case TOKEN_RPAREN:
case SWIG_TOKEN_RPAREN:
if (sp == 0) goto extra_rparen;
/* Might have to reduce operators first */
@ -329,7 +329,7 @@ int SWIG_expr(DOH *s, int *error) {
}
/* Return the expression error message */
char *SWIG_expr_error() {
char *Preprocessor_expr_error() {
return errmsg;
}