diff --git a/ChangeLog b/ChangeLog
index 8778b7ddf..8254dabc6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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 ,
diff --git a/src/frontend/define.c b/src/frontend/define.c
index d7c3c0e0e..2e03de929 100644
--- a/src/frontend/define.c
+++ b/src/frontend/define.c
@@ -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);
 }
diff --git a/src/frontend/evaluate.c b/src/frontend/evaluate.c
index 2f1ac3a1c..67604b626 100644
--- a/src/frontend/evaluate.c
+++ b/src/frontend/evaluate.c
@@ -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);
diff --git a/src/frontend/parse-bison.y b/src/frontend/parse-bison.y
index 070aef64a..52eab77ba 100644
--- a/src/frontend/parse-bison.y
+++ b/src/frontend/parse-bison.y
@@ -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)); }
 ;
 
 %%
diff --git a/src/frontend/parse.c b/src/frontend/parse.c
index 970cf155e..b08f45fed 100644
--- a/src/frontend/parse.c
+++ b/src/frontend/parse.c
@@ -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;
diff --git a/src/include/fteparse.h b/src/include/fteparse.h
index bb9eea0f9..a1d33e0d6 100644
--- a/src/include/fteparse.h
+++ b/src/include/fteparse.h
@@ -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 */