luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add `PT_OP_' prefix to avoid name collision (END, PLUS, MINUS, ...)

This commit is contained in:
rlar 2010-10-09 14:26:41 +00:00
parent 1d62b41bfa
commit 882b3b4155
6 changed files with 81 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ChangeLog
View File

@ -1,3 +1,11 @@
2010-10-09 Robert Larice
* src/frontend/define.c ,
* src/frontend/evaluate.c ,
* src/frontend/parse-bison.y ,
* src/frontend/parse.c ,
* src/include/fteparse.h :
add `PT_OP_' prefix to avoid name collision (END, PLUS, MINUS, ...)
2010-10-09 Robert Larice
* src/frontend/com_cdump.c ,
* src/frontend/com_chdir.c ,

6
src/frontend/define.c
View File

@ -274,7 +274,7 @@ ft_substdef(const char *name, struct pnode *args)
if (args)
arity = 1;
for (tp = args; tp && tp->pn_op && (tp->pn_op->op_num == COMMA); tp =
for (tp = args; tp && tp->pn_op && (tp->pn_op->op_num == PT_OP_COMMA); tp =
tp->pn_right)
arity++;
for (udf = udfuncs; udf; udf = udf->ud_next)
@ -393,7 +393,7 @@ ntharg(int num, struct pnode *args)
if (num > 1) {
while (--num > 0) {
if (ptry && ptry->pn_op &&
(ptry->pn_op->op_num != COMMA)) {
(ptry->pn_op->op_num != PT_OP_COMMA)) {
if (num == 1)
break;
else
@ -402,7 +402,7 @@ ntharg(int num, struct pnode *args)
ptry = ptry->pn_right;
}
}
if (ptry && ptry->pn_op && (ptry->pn_op->op_num == COMMA))
if (ptry && ptry->pn_op && (ptry->pn_op->op_num == PT_OP_COMMA))
ptry = ptry->pn_left;
return (ptry);
}

2
src/frontend/evaluate.c
View File

@ -61,7 +61,7 @@ ft_evaluate(struct pnode *node)
if (node->pn_op->op_arity == 1)
d = ((*node->pn_op->op_func.unary) (node->pn_left));
else if (node->pn_op->op_arity == 2) {
if(node->pn_op->op_num == TERNARY)
if(node->pn_op->op_num == PT_OP_TERNARY)
d = ft_ternary(node);
else
d = (*node->pn_op->op_func.binary) (node->pn_left, node->pn_right);

42
src/frontend/parse-bison.y
View File

@ -126,35 +126,35 @@ exp:
TOK_NUM { $$ = mknnode($1); }
| TOK_STR { $$ = mksnode($1); }
| exp ',' exp { $$ = mkbnode(COMMA, $1, $3); }
| exp '+' exp { $$ = mkbnode(PLUS, $1, $3); }
| exp '-' exp { $$ = mkbnode(MINUS, $1, $3); }
| exp '*' exp { $$ = mkbnode(TIMES, $1, $3); }
| exp '%' exp { $$ = mkbnode(MOD, $1, $3); }
| exp '/' exp { $$ = mkbnode(DIVIDE, $1, $3); }
| exp '^' exp { $$ = mkbnode(POWER, $1, $3); }
| exp ',' exp { $$ = mkbnode(PT_OP_COMMA, $1, $3); }
| exp '+' exp { $$ = mkbnode(PT_OP_PLUS, $1, $3); }
| exp '-' exp { $$ = mkbnode(PT_OP_MINUS, $1, $3); }
| exp '*' exp { $$ = mkbnode(PT_OP_TIMES, $1, $3); }
| exp '%' exp { $$ = mkbnode(PT_OP_MOD, $1, $3); }
| exp '/' exp { $$ = mkbnode(PT_OP_DIVIDE, $1, $3); }
| exp '^' exp { $$ = mkbnode(PT_OP_POWER, $1, $3); }
| '(' exp ')' { $$ = $2; }
| '-' exp %prec NEG { $$ = mkunode(UMINUS, $2); }
| '~' exp { $$ = mkunode(NOT, $2); }
| '-' exp %prec NEG { $$ = mkunode(PT_OP_UMINUS, $2); }
| '~' exp { $$ = mkunode(PT_OP_NOT, $2); }
| TOK_STR '(' exp ')' { $$ = mkfnode($1, $3); if(!$$) YYABORT; }
| exp '=' exp { $$ = mkbnode(EQ, $1, $3); }
| exp TOK_NE exp { $$ = mkbnode(NE, $1, $3); }
| exp '>' exp { $$ = mkbnode(GT, $1, $3); }
| exp '<' exp { $$ = mkbnode(LT, $1, $3); }
| exp TOK_GE exp { $$ = mkbnode(GE, $1, $3); }
| exp TOK_LE exp { $$ = mkbnode(LE, $1, $3); }
| exp '=' exp { $$ = mkbnode(PT_OP_EQ, $1, $3); }
| exp TOK_NE exp { $$ = mkbnode(PT_OP_NE, $1, $3); }
| exp '>' exp { $$ = mkbnode(PT_OP_GT, $1, $3); }
| exp '<' exp { $$ = mkbnode(PT_OP_LT, $1, $3); }
| exp TOK_GE exp { $$ = mkbnode(PT_OP_GE, $1, $3); }
| exp TOK_LE exp { $$ = mkbnode(PT_OP_LE, $1, $3); }
| exp '&' exp { $$ = mkbnode(AND, $1, $3); }
| exp '|' exp { $$ = mkbnode(OR, $1, $3); }
| exp '&' exp { $$ = mkbnode(PT_OP_AND, $1, $3); }
| exp '|' exp { $$ = mkbnode(PT_OP_OR, $1, $3); }
| exp '[' exp ']' { $$ = mkbnode(INDX, $1, $3); }
| exp TOK_LRANGE exp TOK_RRANGE { $$ = mkbnode(RANGE, $1, $3); }
| exp '?' exp ':' exp { $$ = mkbnode(TERNARY,$1,
mkbnode(COMMA,$3,$5)); }
| exp '[' exp ']' { $$ = mkbnode(PT_OP_INDX, $1, $3); }
| exp TOK_LRANGE exp TOK_RRANGE { $$ = mkbnode(PT_OP_RANGE, $1, $3); }
| exp '?' exp ':' exp { $$ = mkbnode(PT_OP_TERNARY,$1,
mkbnode(PT_OP_COMMA,$3,$5)); }
;
%%

48
src/frontend/parse.c
View File

@ -106,32 +106,32 @@ checkvalid(struct pnode *pn)
static
struct op ops[] = {
{ PLUS, "+", 2, {(void(*)(void)) op_plus} } ,
{ MINUS, "-", 2, {(void(*)(void)) op_minus} } ,
{ TIMES, "*", 2, {(void(*)(void)) op_times} } ,
{ MOD, "%", 2, {(void(*)(void)) op_mod} } ,
{ DIVIDE, "/", 2, {(void(*)(void)) op_divide} } ,
{ COMMA, ",", 2, {(void(*)(void)) op_comma} } ,
{ POWER, "^", 2, {(void(*)(void)) op_power} } ,
{ EQ, "=", 2, {(void(*)(void)) op_eq} } ,
{ GT, ">", 2, {(void(*)(void)) op_gt} } ,
{ LT, "<", 2, {(void(*)(void)) op_lt} } ,
{ GE, ">=", 2, {(void(*)(void)) op_ge} } ,
{ LE, "<=", 2, {(void(*)(void)) op_le} } ,
{ NE, "<>", 2, {(void(*)(void)) op_ne} } ,
{ AND, "&", 2, {(void(*)(void)) op_and} } ,
{ OR, "|", 2, {(void(*)(void)) op_or} } ,
{ INDX, "[", 2, {(void(*)(void)) op_ind} } ,
{ RANGE, "[[", 2, {(void(*)(void)) op_range} } ,
{ TERNARY, "?:", 2, {NULL} } ,
{ 0, NULL, 0, {NULL} }
{ PT_OP_PLUS, "+", 2, {(void(*)(void)) op_plus} } ,
{ PT_OP_MINUS, "-", 2, {(void(*)(void)) op_minus} } ,
{ PT_OP_TIMES, "*", 2, {(void(*)(void)) op_times} } ,
{ PT_OP_MOD, "%", 2, {(void(*)(void)) op_mod} } ,
{ PT_OP_DIVIDE, "/", 2, {(void(*)(void)) op_divide} } ,
{ PT_OP_COMMA, ",", 2, {(void(*)(void)) op_comma} } ,
{ PT_OP_POWER, "^", 2, {(void(*)(void)) op_power} } ,
{ PT_OP_EQ, "=", 2, {(void(*)(void)) op_eq} } ,
{ PT_OP_GT, ">", 2, {(void(*)(void)) op_gt} } ,
{ PT_OP_LT, "<", 2, {(void(*)(void)) op_lt} } ,
{ PT_OP_GE, ">=", 2, {(void(*)(void)) op_ge} } ,
{ PT_OP_LE, "<=", 2, {(void(*)(void)) op_le} } ,
{ PT_OP_NE, "<>", 2, {(void(*)(void)) op_ne} } ,
{ PT_OP_AND, "&", 2, {(void(*)(void)) op_and} } ,
{ PT_OP_OR, "|", 2, {(void(*)(void)) op_or} } ,
{ PT_OP_INDX, "[", 2, {(void(*)(void)) op_ind} } ,
{ PT_OP_RANGE, "[[", 2, {(void(*)(void)) op_range} } ,
{ PT_OP_TERNARY, "?:", 2, {NULL} } ,
{ 0, NULL, 0, {NULL} }
} ;
static
struct op uops[] = {
{ UMINUS, "-", 1, {(void(*)(void)) op_uminus} } ,
{ NOT, "~", 1, {(void(*)(void)) op_not} } ,
{ 0, NULL, 0, {NULL} }
{ PT_OP_UMINUS, "-", 1, {(void(*)(void)) op_uminus} } ,
{ PT_OP_NOT, "~", 1, {(void(*)(void)) op_not} } ,
{ 0, NULL, 0, {NULL} }
} ;
/* We have 'v' declared as a function, because if we don't then the defines
@ -289,8 +289,8 @@ mkfnode(const char *func, struct pnode *arg)
return (NULL);
}
if (!f->fu_func && arg->pn_op && arg->pn_op->op_num == COMMA) {
p = mkbnode(MINUS, mkfnode(func, arg->pn_left),
if (!f->fu_func && arg->pn_op && arg->pn_op->op_num == PT_OP_COMMA) {
p = mkbnode(PT_OP_MINUS, mkfnode(func, arg->pn_left),
mkfnode(func, arg->pn_right));
tfree(arg);
return p;

48
src/include/fteparse.h
View File

@ -77,30 +77,30 @@ struct element {
/* See the table in parse.c */
#define END 0
#define PLUS 1
#define MINUS 2
#define TIMES 3
#define MOD 4
#define DIVIDE 5
#define POWER 6
#define UMINUS 7
#define LPAREN 8
#define RPAREN 9
#define COMMA 10
#define VALUE 11
#define EQ 12
#define GT 13
#define LT 14
#define GE 15
#define LE 16
#define NE 17
#define AND 18
#define OR 19
#define NOT 20
#define INDX 21
#define RANGE 22
#define TERNARY 23
#define PT_OP_END 0
#define PT_OP_PLUS 1
#define PT_OP_MINUS 2
#define PT_OP_TIMES 3
#define PT_OP_MOD 4
#define PT_OP_DIVIDE 5
#define PT_OP_POWER 6
#define PT_OP_UMINUS 7
#define PT_OP_LPAREN 8
#define PT_OP_RPAREN 9
#define PT_OP_COMMA 10
#define PT_OP_VALUE 11
#define PT_OP_EQ 12
#define PT_OP_GT 13
#define PT_OP_LT 14
#define PT_OP_GE 15
#define PT_OP_LE 16
#define PT_OP_NE 17
#define PT_OP_AND 18
#define PT_OP_OR 19
#define PT_OP_NOT 20
#define PT_OP_INDX 21
#define PT_OP_RANGE 22
#define PT_OP_TERNARY 23
#endif /* FTEPARSE */