ANSI-fication and Py_PROTO extermination.

1 files changed, 61 insertions, 59 deletions

diff --git a/Include/abstract.h b/Include/abstract.h
index f180806..6b96adf 100644
--- a/Include/abstract.h
+++ b/Include/abstract.h
@@ -233,7 +233,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        */
 #define  PyObject_DelAttr(O,A) PyObject_SetAttr((O),(A),NULL)
 
-     DL_IMPORT(int) PyObject_Cmp Py_PROTO((PyObject *o1, PyObject *o2, int *result));
+     DL_IMPORT(int) PyObject_Cmp(PyObject *o1, PyObject *o2, int *result);
 
        /*
 	 Compare the values of o1 and o2 using a routine provided by
@@ -281,7 +281,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(int) PyCallable_Check Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PyCallable_Check(PyObject *o);
 
        /*
 	 Determine if the object, o, is callable.  Return 1 if the
@@ -293,8 +293,8 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
 
      
-     DL_IMPORT(PyObject *) PyObject_CallObject Py_PROTO((PyObject *callable_object,
-					     PyObject *args));
+     DL_IMPORT(PyObject *) PyObject_CallObject(PyObject *callable_object,
+                                               PyObject *args);
 
        /*
 
@@ -306,8 +306,8 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyObject_CallFunction Py_PROTO((PyObject *callable_object,
-					       char *format, ...));
+     DL_IMPORT(PyObject *) PyObject_CallFunction(PyObject *callable_object,
+                                                 char *format, ...);
 
        /*
 	 Call a callable Python object, callable_object, with a
@@ -320,8 +320,8 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        */
 
 
-     DL_IMPORT(PyObject *) PyObject_CallMethod Py_PROTO((PyObject *o, char *m,
-					     char *format, ...));
+     DL_IMPORT(PyObject *) PyObject_CallMethod(PyObject *o, char *m,
+                                               char *format, ...);
 
        /*
 	 Call the method named m of object o with a variable number of
@@ -373,7 +373,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 
        */
 
-     DL_IMPORT(PyObject *) PyObject_Type Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyObject_Type(PyObject *o);
 
        /*
 	 On success, returns a type object corresponding to the object
@@ -381,7 +381,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 equivalent to the Python expression: type(o).
        */
 
-     DL_IMPORT(int) PyObject_Length Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PyObject_Length(PyObject *o);
 
        /*
          Return the length of object o.  If the object, o, provides
@@ -391,7 +391,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyObject_GetItem Py_PROTO((PyObject *o, PyObject *key));
+     DL_IMPORT(PyObject *) PyObject_GetItem(PyObject *o, PyObject *key);
 
        /*
 	 Return element of o corresponding to the object, key, or NULL
@@ -400,7 +400,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(int) PyObject_SetItem Py_PROTO((PyObject *o, PyObject *key, PyObject *v));
+     DL_IMPORT(int) PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);
 
        /*
 	 Map the object, key, to the value, v.  Returns
@@ -408,7 +408,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 statement: o[key]=v.
        */
 
-     DL_IMPORT(int) PyObject_DelItem Py_PROTO((PyObject *o, PyObject *key));
+     DL_IMPORT(int) PyObject_DelItem(PyObject *o, PyObject *key);
 
        /*
 	 Delete the mapping for key from *o.  Returns -1 on failure.
@@ -464,7 +464,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
 /*  Number Protocol:*/
 
-     DL_IMPORT(int) PyNumber_Check Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PyNumber_Check(PyObject *o);
 
        /*
          Returns 1 if the object, o, provides numeric protocols, and
@@ -474,7 +474,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Add Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Add(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of adding o1 and o2, or null on failure.
@@ -483,7 +483,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Subtract Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Subtract(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of subtracting o2 from o1, or null on
@@ -492,7 +492,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Multiply Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Multiply(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of multiplying o1 and o2, or null on
@@ -502,7 +502,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Divide Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Divide(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of dividing o1 by o2, or null on failure.
@@ -511,7 +511,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Remainder Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Remainder(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the remainder of dividing o1 by o2, or null on
@@ -521,7 +521,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Divmod Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Divmod(PyObject *o1, PyObject *o2);
 
        /*
 	 See the built-in function divmod.  Returns NULL on failure.
@@ -531,7 +531,8 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Power Py_PROTO((PyObject *o1, PyObject *o2, PyObject *o3));
+     DL_IMPORT(PyObject *) PyNumber_Power(PyObject *o1, PyObject *o2,
+                                          PyObject *o3);
 
        /*
 	 See the built-in function pow.  Returns NULL on failure.
@@ -540,7 +541,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Negative Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Negative(PyObject *o);
 
        /*
 	 Returns the negation of o on success, or null on failure.
@@ -548,7 +549,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Positive Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Positive(PyObject *o);
 
        /*
          Returns the (what?) of o on success, or NULL on failure.
@@ -556,7 +557,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Absolute Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Absolute(PyObject *o);
 
        /*
 	 Returns the absolute value of o, or null on failure.  This is
@@ -564,7 +565,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Invert Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Invert(PyObject *o);
 
        /*
 	 Returns the bitwise negation of o on success, or NULL on
@@ -574,7 +575,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Lshift Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Lshift(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of left shifting o1 by o2 on success, or
@@ -584,7 +585,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Rshift Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Rshift(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of right shifting o1 by o2 on success, or
@@ -593,7 +594,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_And Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_And(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of bitwise and of o1 and o2 on success, or
@@ -603,7 +604,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Xor Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the bitwise exclusive or of o1 by o2 on success, or
@@ -613,7 +614,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Or Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2);
 
        /*
 	 Returns the result of bitwise or or o1 and o2 on success, or
@@ -641,7 +642,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Int Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Int(PyObject *o);
 
        /*
 	 Returns the o converted to an integer object on success, or
@@ -650,7 +651,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Long Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Long(PyObject *o);
 
        /*
 	 Returns the o converted to a long integer object on success,
@@ -659,7 +660,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PyNumber_Float Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PyNumber_Float(PyObject *o);
 
        /*
 	 Returns the o converted to a float object on success, or NULL
@@ -670,7 +671,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
 /*  Sequence protocol:*/
 
-     DL_IMPORT(int) PySequence_Check Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PySequence_Check(PyObject *o);
 
        /*
          Return 1 if the object provides sequence protocol, and zero
@@ -680,14 +681,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(int) PySequence_Length Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PySequence_Length(PyObject *o);
 
        /*
          Return the length of sequence object o, or -1 on failure.
 
        */
 
-     DL_IMPORT(PyObject *) PySequence_Concat Py_PROTO((PyObject *o1, PyObject *o2));
+     DL_IMPORT(PyObject *) PySequence_Concat(PyObject *o1, PyObject *o2);
 
        /*
 	 Return the concatination of o1 and o2 on success, and NULL on
@@ -696,7 +697,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PySequence_Repeat Py_PROTO((PyObject *o, int count));
+     DL_IMPORT(PyObject *) PySequence_Repeat(PyObject *o, int count);
 
        /*
 	 Return the result of repeating sequence object o count times,
@@ -705,14 +706,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(PyObject *) PySequence_GetItem Py_PROTO((PyObject *o, int i));
+     DL_IMPORT(PyObject *) PySequence_GetItem(PyObject *o, int i);
 
        /*
 	 Return the ith element of o, or NULL on failure. This is the
 	 equivalent of the Python expression: o[i].
        */
 
-     DL_IMPORT(PyObject *) PySequence_GetSlice Py_PROTO((PyObject *o, int i1, int i2));
+     DL_IMPORT(PyObject *) PySequence_GetSlice(PyObject *o, int i1, int i2);
 
        /*
 	 Return the slice of sequence object o between i1 and i2, or
@@ -721,7 +722,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(int) PySequence_SetItem Py_PROTO((PyObject *o, int i, PyObject *v));
+     DL_IMPORT(int) PySequence_SetItem(PyObject *o, int i, PyObject *v);
 
        /*
 	 Assign object v to the ith element of o.  Returns
@@ -730,7 +731,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
-     DL_IMPORT(int) PySequence_DelItem Py_PROTO((PyObject *o, int i));
+     DL_IMPORT(int) PySequence_DelItem(PyObject *o, int i);
 
        /*
 	 Delete the ith element of object v.  Returns
@@ -738,7 +739,8 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 statement: del o[i].
        */
 
-     DL_IMPORT(int) PySequence_SetSlice Py_PROTO((PyObject *o, int i1, int i2, PyObject *v));
+     DL_IMPORT(int) PySequence_SetSlice(PyObject *o, int i1, int i2,
+                                        PyObject *v);
 
        /*
          Assign the sequence object, v, to the slice in sequence
@@ -746,7 +748,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 equivalent of the Python statement: o[i1:i2]=v.
        */
 
-     DL_IMPORT(int) PySequence_DelSlice Py_PROTO((PyObject *o, int i1, int i2));
+     DL_IMPORT(int) PySequence_DelSlice(PyObject *o, int i1, int i2);
 
        /*
 	 Delete the slice in sequence object, o, from i1 to i2.
@@ -754,7 +756,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 statement: del o[i1:i2].
        */
 
-     DL_IMPORT(PyObject *) PySequence_Tuple Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PySequence_Tuple(PyObject *o);
 
        /*
 	 Returns the sequence, o, as a tuple on success, and NULL on failure.
@@ -762,14 +764,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        */
 
 
-     DL_IMPORT(PyObject *) PySequence_List Py_PROTO((PyObject *o));
+     DL_IMPORT(PyObject *) PySequence_List(PyObject *o);
 
        /*
 	 Returns the sequence, o, as a list on success, and NULL on failure.
 	 This is equivalent to the Python expression: list(o)
        */
 
-     DL_IMPORT(PyObject *) PySequence_Fast Py_PROTO((PyObject *o, const char* m));
+     DL_IMPORT(PyObject *) PySequence_Fast(PyObject *o, const char* m);
 
        /*
          Returns the sequence, o, as a tuple, unless it's already a
@@ -788,7 +790,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
          PySequence_Fast, and that i is within bounds.
        */
 
-     DL_IMPORT(int) PySequence_Count Py_PROTO((PyObject *o, PyObject *value));
+     DL_IMPORT(int) PySequence_Count(PyObject *o, PyObject *value);
 
        /*
          Return the number of occurrences on value on o, that is,
@@ -797,11 +799,11 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 expression: o.count(value).
        */
 
-     DL_IMPORT(int) PySequence_Contains Py_PROTO((PyObject *o, PyObject *value));
+     DL_IMPORT(int) PySequence_Contains(PyObject *o, PyObject *value);
 
 /* For DLL-level backwards compatibility */
 #undef PySequence_In
-     DL_IMPORT(int) PySequence_In Py_PROTO((PyObject *o, PyObject *value));
+     DL_IMPORT(int) PySequence_In(PyObject *o, PyObject *value);
 
 /* For source-level backwards compatibility */
 #define PySequence_In PySequence_Contains
@@ -812,7 +814,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 is equivalent to the Python expression: value in o.
        */
 
-     DL_IMPORT(int) PySequence_Index Py_PROTO((PyObject *o, PyObject *value));
+     DL_IMPORT(int) PySequence_Index(PyObject *o, PyObject *value);
 
        /*
 	 Return the first index for which o[i]=value.  On error,
@@ -822,7 +824,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
 /*  Mapping protocol:*/
 
-     DL_IMPORT(int) PyMapping_Check Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PyMapping_Check(PyObject *o);
 
        /*
          Return 1 if the object provides mapping protocol, and zero
@@ -831,7 +833,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 This function always succeeds.
        */
 
-     DL_IMPORT(int) PyMapping_Length Py_PROTO((PyObject *o));
+     DL_IMPORT(int) PyMapping_Length(PyObject *o);
 
        /*
          Returns the number of keys in object o on success, and -1 on
@@ -841,7 +843,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      /* implemented as a macro:
 
-     int PyMapping_DelItemString Py_PROTO((PyObject *o, char *key));
+     int PyMapping_DelItemString(PyObject *o, char *key);
 
 	 Remove the mapping for object, key, from the object *o.
 	 Returns -1 on failure.  This is equivalent to
@@ -851,7 +853,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
      /* implemented as a macro:
 
-     int PyMapping_DelItem Py_PROTO((PyObject *o, PyObject *key));
+     int PyMapping_DelItem(PyObject *o, PyObject *key);
 
 	 Remove the mapping for object, key, from the object *o.
 	 Returns -1 on failure.  This is equivalent to
@@ -859,7 +861,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        */
 #define PyMapping_DelItem(O,K) PyDict_DelItem((O),(K))
 
-     DL_IMPORT(int) PyMapping_HasKeyString Py_PROTO((PyObject *o, char *key));
+     DL_IMPORT(int) PyMapping_HasKeyString(PyObject *o, char *key);
 
        /*
 	 On success, return 1 if the mapping object has the key, key,
@@ -869,7 +871,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 This function always succeeds.
        */
 
-     DL_IMPORT(int) PyMapping_HasKey Py_PROTO((PyObject *o, PyObject *key));
+     DL_IMPORT(int) PyMapping_HasKey(PyObject *o, PyObject *key);
 
        /*
 	 Return 1 if the mapping object has the key, key,
@@ -912,7 +914,7 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
        */
 #define PyMapping_Items(O) PyObject_CallMethod(O,"items",NULL)
 
-     DL_IMPORT(PyObject *) PyMapping_GetItemString Py_PROTO((PyObject *o, char *key));
+     DL_IMPORT(PyObject *) PyMapping_GetItemString(PyObject *o, char *key);
 
        /*
 	 Return element of o corresponding to the object, key, or NULL
@@ -920,8 +922,8 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 	 o[key].
        */
 
-     DL_IMPORT(int) PyMapping_SetItemString Py_PROTO((PyObject *o, char *key,
-					   PyObject *value));
+     DL_IMPORT(int) PyMapping_SetItemString(PyObject *o, char *key,
+                                            PyObject *value);
 
        /*
 	 Map the object, key, to the value, v.  Returns