--- util/neo_err.h.orig	Thu Dec 15 23:17:36 2005
+++ util/neo_err.h	Mon May  8 16:54:19 2006
@@ -105,7 +105,7 @@ NEOERR *nerr_raise_errnof (const char *f
 #define nerr_pass(e) \
    nerr_passf(__PRETTY_FUNCTION__,__FILE__,__LINE__,e)
 NEOERR *nerr_passf (const char *func, const char *file, int lineno, 
-                    NEOERR *err);
+                    NEOERR *nerr);
 
 /* function: nerr_pass_ctx
  * description: this function is used to pass an error up a level in the
@@ -127,47 +127,47 @@ NEOERR *nerr_passf (const char *func, co
 #define nerr_pass_ctx(e,f,...) \
    nerr_pass_ctxf(__PRETTY_FUNCTION__,__FILE__,__LINE__,e,f,__VA_ARGS__)
 #endif
-NEOERR *nerr_pass_ctxf (const char *func, const char *file, int lineno, NEOERR *err, 
+NEOERR *nerr_pass_ctxf (const char *func, const char *file, int lineno, NEOERR *nerr, 
                        const char *fmt, ...);
 
 /* function: nerr_log_error
  * description: currently, this prints out the error to stderr, and
  *             free's the error chain
  */
-void nerr_log_error (NEOERR *err);
+void nerr_log_error (NEOERR *nerr);
 
 #include "util/neo_str.h"
 /* function: nerr_error_string
  * description: returns the string associated with an error (the bottom
  *              level of the error chain)
- * arguments: err - error
+ * arguments: nerr - error
  *            str - string to which the data is appended
  * returns: None - errors appending to the string are ignored
  */
-void nerr_error_string (NEOERR *err, STRING *str);
+void nerr_error_string (NEOERR *nerr, STRING *str);
 
 /* function: nerr_error_traceback
  * description: returns the full traceback of the error chain
- * arguments: err - error
+ * arguments: nerr - error
  *            str - string to which the data is appended
  * returns: None - errors appending to the string are ignored
  */
-void nerr_error_traceback (NEOERR *err, STRING *str);
+void nerr_error_traceback (NEOERR *nerr, STRING *str);
 
 /* function: nerr_ignore
  * description: you should only call this if you actually handle the
  *              error (should I rename it?).  Free's the error chain.
  */
-void nerr_ignore (NEOERR **err);
+void nerr_ignore (NEOERR **nerr);
 
 /* function: nerr_register
  * description: register an error type.  This will assign a numeric value
  *              to the type, and keep track of the "pretty name" for it.
- * arguments: err - pointer to a NERR_TYPE
+ * arguments: nerr - pointer to a NERR_TYPE
  *            name - pretty name for the error type 
  * returns: NERR_NOMEM on no memory
  */
-NEOERR *nerr_register (NERR_TYPE *err, const char *name);
+NEOERR *nerr_register (NERR_TYPE *nerr, const char *name);
 
 /* function: nerr_init
  * description: initialize the NEOERR system.  Can be called more than once.
@@ -186,21 +186,21 @@ NEOERR *nerr_init (void);
  *              parlance, this would be the equivalent of "catch".
  *              Typically, you can just compare a NEOERR against STATUS_OK
  *              or just test for true if you are checking for any error.
- * arguments: err - the NEOERR that has an error. 
+ * arguments: nerr - the NEOERR that has an error. 
  *            type - the NEOERR type, as registered with nerr_register
  * returns: true on match
  */
-int nerr_match (NEOERR *err, NERR_TYPE type);
+int nerr_match (NEOERR *nerr, NERR_TYPE type);
 
 /* function: nerr_handle
  * description: nerr_handle is a convenience function.  It is the equivalent
  *              of nerr_match, but it will also deallocate the error chain
  *              on a match.
- * arguments: err - pointer to a pointer NEOERR 
+ * arguments: nerr - pointer to a pointer NEOERR 
  *            type - the NEOERR type, as registered with nerr_register
  * returns: true on match
  */
-int nerr_handle (NEOERR **err, NERR_TYPE type);
+int nerr_handle (NEOERR **nerr, NERR_TYPE type);
 
 __END_DECLS