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 2010-10-09 Robert Larice
* src/frontend/com_cdump.c , * src/frontend/com_cdump.c ,
* src/frontend/com_chdir.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) if (args)
arity = 1; 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) tp->pn_right)
arity++; arity++;
for (udf = udfuncs; udf; udf = udf->ud_next) for (udf = udfuncs; udf; udf = udf->ud_next)
@ -393,7 +393,7 @@ ntharg(int num, struct pnode *args)
if (num > 1) { if (num > 1) {
while (--num > 0) { while (--num > 0) {
if (ptry && ptry->pn_op && if (ptry && ptry->pn_op &&
(ptry->pn_op->op_num != COMMA)) { (ptry->pn_op->op_num != PT_OP_COMMA)) {
if (num == 1) if (num == 1)
break; break;
else else
@ -402,7 +402,7 @@ ntharg(int num, struct pnode *args)
ptry = ptry->pn_right; 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; ptry = ptry->pn_left;
return (ptry); 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) if (node->pn_op->op_arity == 1)
d = ((*node->pn_op->op_func.unary) (node->pn_left)); d = ((*node->pn_op->op_func.unary) (node->pn_left));
else if (node->pn_op->op_arity == 2) { 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); d = ft_ternary(node);
else else
d = (*node->pn_op->op_func.binary) (node->pn_left, node->pn_right); 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_NUM { $$ = mknnode($1); }
| TOK_STR { $$ = mksnode($1); } | TOK_STR { $$ = mksnode($1); }
| exp ',' exp { $$ = mkbnode(COMMA, $1, $3); } | exp ',' exp { $$ = mkbnode(PT_OP_COMMA, $1, $3); }
| exp '+' exp { $$ = mkbnode(PLUS, $1, $3); } | exp '+' exp { $$ = mkbnode(PT_OP_PLUS, $1, $3); }
| exp '-' exp { $$ = mkbnode(MINUS, $1, $3); } | exp '-' exp { $$ = mkbnode(PT_OP_MINUS, $1, $3); }
| exp '*' exp { $$ = mkbnode(TIMES, $1, $3); } | exp '*' exp { $$ = mkbnode(PT_OP_TIMES, $1, $3); }
| exp '%' exp { $$ = mkbnode(MOD, $1, $3); } | exp '%' exp { $$ = mkbnode(PT_OP_MOD, $1, $3); }
| exp '/' exp { $$ = mkbnode(DIVIDE, $1, $3); } | exp '/' exp { $$ = mkbnode(PT_OP_DIVIDE, $1, $3); }
| exp '^' exp { $$ = mkbnode(POWER, $1, $3); } | exp '^' exp { $$ = mkbnode(PT_OP_POWER, $1, $3); }
| '(' exp ')' { $$ = $2; } | '(' exp ')' { $$ = $2; }
| '-' exp %prec NEG { $$ = mkunode(UMINUS, $2); } | '-' exp %prec NEG { $$ = mkunode(PT_OP_UMINUS, $2); }
| '~' exp { $$ = mkunode(NOT, $2); } | '~' exp { $$ = mkunode(PT_OP_NOT, $2); }
| TOK_STR '(' exp ')' { $$ = mkfnode($1, $3); if(!$$) YYABORT; } | TOK_STR '(' exp ')' { $$ = mkfnode($1, $3); if(!$$) YYABORT; }
| exp '=' exp { $$ = mkbnode(EQ, $1, $3); } | exp '=' exp { $$ = mkbnode(PT_OP_EQ, $1, $3); }
| exp TOK_NE exp { $$ = mkbnode(NE, $1, $3); } | exp TOK_NE exp { $$ = mkbnode(PT_OP_NE, $1, $3); }
| exp '>' exp { $$ = mkbnode(GT, $1, $3); } | exp '>' exp { $$ = mkbnode(PT_OP_GT, $1, $3); }
| exp '<' exp { $$ = mkbnode(LT, $1, $3); } | exp '<' exp { $$ = mkbnode(PT_OP_LT, $1, $3); }
| exp TOK_GE exp { $$ = mkbnode(GE, $1, $3); } | exp TOK_GE exp { $$ = mkbnode(PT_OP_GE, $1, $3); }
| exp TOK_LE exp { $$ = mkbnode(LE, $1, $3); } | exp TOK_LE exp { $$ = mkbnode(PT_OP_LE, $1, $3); }
| exp '&' exp { $$ = mkbnode(AND, $1, $3); } | exp '&' exp { $$ = mkbnode(PT_OP_AND, $1, $3); }
| exp '|' exp { $$ = mkbnode(OR, $1, $3); } | exp '|' exp { $$ = mkbnode(PT_OP_OR, $1, $3); }
| exp '[' exp ']' { $$ = mkbnode(INDX, $1, $3); } | exp '[' exp ']' { $$ = mkbnode(PT_OP_INDX, $1, $3); }
| exp TOK_LRANGE exp TOK_RRANGE { $$ = mkbnode(RANGE, $1, $3); } | exp TOK_LRANGE exp TOK_RRANGE { $$ = mkbnode(PT_OP_RANGE, $1, $3); }
| exp '?' exp ':' exp { $$ = mkbnode(TERNARY,$1, | exp '?' exp ':' exp { $$ = mkbnode(PT_OP_TERNARY,$1,
mkbnode(COMMA,$3,$5)); } mkbnode(PT_OP_COMMA,$3,$5)); }
; ;
%% %%

48
src/frontend/parse.c
View File

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

48
src/include/fteparse.h
View File

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