diff options
| -rw-r--r-- | Include/abstract.h | 120 | ||||
| -rw-r--r-- | Include/bufferobject.h | 26 | ||||
| -rw-r--r-- | Include/classobject.h | 65 | ||||
| -rw-r--r-- | Include/cobject.h | 24 | ||||
| -rw-r--r-- | Include/compile.h | 48 | ||||
| -rw-r--r-- | Include/complexobject.h | 34 | ||||
| -rw-r--r-- | Include/fileobject.h | 32 | ||||
| -rw-r--r-- | Include/floatobject.h | 22 | ||||
| -rw-r--r-- | Include/frameobject.h | 69 | ||||
| -rw-r--r-- | Include/funcobject.h | 34 | ||||
| -rw-r--r-- | Include/grammar.h | 90 | ||||
| -rw-r--r-- | Include/intobject.h | 30 | ||||
| -rw-r--r-- | Include/listobject.h | 38 | ||||
| -rw-r--r-- | Include/methodobject.h | 46 |
14 files changed, 340 insertions, 338 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 diff --git a/Include/bufferobject.h b/Include/bufferobject.h index da978c2..5a205f3 100644 --- a/Include/bufferobject.h +++ b/Include/bufferobject.h @@ -1,9 +1,3 @@ -#ifndef Py_BUFFEROBJECT_H -#define Py_BUFFEROBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -18,6 +12,12 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Note: the object's structure is private */ +#ifndef Py_BUFFEROBJECT_H +#define Py_BUFFEROBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + extern DL_IMPORT(PyTypeObject) PyBuffer_Type; @@ -25,16 +25,18 @@ extern DL_IMPORT(PyTypeObject) PyBuffer_Type; #define Py_END_OF_BUFFER (-1) -extern DL_IMPORT(PyObject *) PyBuffer_FromObject Py_PROTO((PyObject *base, int offset, int size)); -extern DL_IMPORT(PyObject *) PyBuffer_FromReadWriteObject Py_PROTO((PyObject *base, int offset, int size)); +extern DL_IMPORT(PyObject *) PyBuffer_FromObject(PyObject *base, + int offset, int size); +extern DL_IMPORT(PyObject *) PyBuffer_FromReadWriteObject(PyObject *base, + int offset, + int size); -extern DL_IMPORT(PyObject *) PyBuffer_FromMemory Py_PROTO((void *ptr, int size)); -extern DL_IMPORT(PyObject *) PyBuffer_FromReadWriteMemory Py_PROTO((void *ptr, int size)); +extern DL_IMPORT(PyObject *) PyBuffer_FromMemory(void *ptr, int size); +extern DL_IMPORT(PyObject *) PyBuffer_FromReadWriteMemory(void *ptr, int size); -extern DL_IMPORT(PyObject *) PyBuffer_New Py_PROTO((int size)); +extern DL_IMPORT(PyObject *) PyBuffer_New(int size); #ifdef __cplusplus } #endif #endif /* !Py_BUFFEROBJECT_H */ - diff --git a/Include/classobject.h b/Include/classobject.h index 7fcf6ec..2902e77 100644 --- a/Include/classobject.h +++ b/Include/classobject.h @@ -1,9 +1,3 @@ -#ifndef Py_CLASSOBJECT_H -#define Py_CLASSOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -18,28 +12,34 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Revealing some structures (not for general use) */ +#ifndef Py_CLASSOBJECT_H +#define Py_CLASSOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { - PyObject_HEAD - PyObject *cl_bases; /* A tuple of class objects */ - PyObject *cl_dict; /* A dictionary */ - PyObject *cl_name; /* A string */ - /* The following three are functions or NULL */ - PyObject *cl_getattr; - PyObject *cl_setattr; - PyObject *cl_delattr; + PyObject_HEAD + PyObject *cl_bases; /* A tuple of class objects */ + PyObject *cl_dict; /* A dictionary */ + PyObject *cl_name; /* A string */ + /* The following three are functions or NULL */ + PyObject *cl_getattr; + PyObject *cl_setattr; + PyObject *cl_delattr; } PyClassObject; typedef struct { - PyObject_HEAD - PyClassObject *in_class; /* The class object */ - PyObject *in_dict; /* A dictionary */ + PyObject_HEAD + PyClassObject *in_class; /* The class object */ + PyObject *in_dict; /* A dictionary */ } PyInstanceObject; typedef struct { - PyObject_HEAD - PyObject *im_func; /* The callable object implementing the method */ - PyObject *im_self; /* The instance it is bound to, or NULL */ - PyObject *im_class; /* The class that defined the method */ + PyObject_HEAD + PyObject *im_func; /* The callable object implementing the method */ + PyObject *im_self; /* The instance it is bound to, or NULL */ + PyObject *im_class; /* The class that defined the method */ } PyMethodObject; extern DL_IMPORT(PyTypeObject) PyClass_Type, PyInstance_Type, PyMethod_Type; @@ -48,13 +48,14 @@ extern DL_IMPORT(PyTypeObject) PyClass_Type, PyInstance_Type, PyMethod_Type; #define PyInstance_Check(op) ((op)->ob_type == &PyInstance_Type) #define PyMethod_Check(op) ((op)->ob_type == &PyMethod_Type) -extern DL_IMPORT(PyObject *) PyClass_New Py_PROTO((PyObject *, PyObject *, PyObject *)); -extern DL_IMPORT(PyObject *) PyInstance_New Py_PROTO((PyObject *, PyObject *, PyObject *)); -extern DL_IMPORT(PyObject *) PyMethod_New Py_PROTO((PyObject *, PyObject *, PyObject *)); +extern DL_IMPORT(PyObject *) PyClass_New(PyObject *, PyObject *, PyObject *); +extern DL_IMPORT(PyObject *) PyInstance_New(PyObject *, PyObject *, + PyObject *); +extern DL_IMPORT(PyObject *) PyMethod_New(PyObject *, PyObject *, PyObject *); -extern DL_IMPORT(PyObject *) PyMethod_Function Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyMethod_Self Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyMethod_Class Py_PROTO((PyObject *)); +extern DL_IMPORT(PyObject *) PyMethod_Function(PyObject *); +extern DL_IMPORT(PyObject *) PyMethod_Self(PyObject *); +extern DL_IMPORT(PyObject *) PyMethod_Class(PyObject *); /* Macros for direct access to these values. Type checks are *not* done, so use with care. */ @@ -65,12 +66,12 @@ extern DL_IMPORT(PyObject *) PyMethod_Class Py_PROTO((PyObject *)); #define PyMethod_GET_CLASS(meth) \ (((PyMethodObject *)meth) -> im_class) -extern DL_IMPORT(int) PyClass_IsSubclass Py_PROTO((PyObject *, PyObject *)); +extern DL_IMPORT(int) PyClass_IsSubclass(PyObject *, PyObject *); -extern DL_IMPORT(PyObject *) PyInstance_DoBinOp - Py_PROTO((PyObject *, PyObject *, - char *, char *, - PyObject * (*) Py_PROTO((PyObject *, PyObject *)) )); +extern DL_IMPORT(PyObject *) PyInstance_DoBinOp(PyObject *, PyObject *, + char *, char *, + PyObject * (*)(PyObject *, + PyObject *)); #ifdef __cplusplus } diff --git a/Include/cobject.h b/Include/cobject.h index 49c5450..15850d9 100644 --- a/Include/cobject.h +++ b/Include/cobject.h @@ -1,9 +1,3 @@ -#ifndef Py_COBJECT_H -#define Py_COBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -23,6 +17,12 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. */ +#ifndef Py_COBJECT_H +#define Py_COBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + extern DL_IMPORT(PyTypeObject) PyCObject_Type; #define PyCObject_Check(op) ((op)->ob_type == &PyCObject_Type) @@ -34,7 +34,7 @@ extern DL_IMPORT(PyTypeObject) PyCObject_Type; */ extern DL_IMPORT(PyObject *) -PyCObject_FromVoidPtr Py_PROTO((void *cobj, void (*destruct)(void*))); +PyCObject_FromVoidPtr(void *cobj, void (*destruct)(void*)); /* Create a PyCObject from a pointer to a C object, a description object, @@ -43,20 +43,20 @@ PyCObject_FromVoidPtr Py_PROTO((void *cobj, void (*destruct)(void*))); the PyCObject is destroyed. */ extern DL_IMPORT(PyObject *) -PyCObject_FromVoidPtrAndDesc Py_PROTO((void *cobj, void *desc, - void (*destruct)(void*,void*))); +PyCObject_FromVoidPtrAndDesc(void *cobj, void *desc, + void (*destruct)(void*,void*)); /* Retrieve a pointer to a C object from a PyCObject. */ extern DL_IMPORT(void *) -PyCObject_AsVoidPtr Py_PROTO((PyObject *)); +PyCObject_AsVoidPtr(PyObject *); /* Retrieve a pointer to a description object from a PyCObject. */ extern DL_IMPORT(void *) -PyCObject_GetDesc Py_PROTO((PyObject *)); +PyCObject_GetDesc(PyObject *); /* Import a pointer to a C object from a module using a PyCObject. */ extern DL_IMPORT(void *) -PyCObject_Import Py_PROTO((char *module_name, char *cobject_name)); +PyCObject_Import(char *module_name, char *cobject_name); #ifdef __cplusplus } diff --git a/Include/compile.h b/Include/compile.h index de1b579..56973cd 100644 --- a/Include/compile.h +++ b/Include/compile.h @@ -1,9 +1,3 @@ -#ifndef Py_COMPILE_H -#define Py_COMPILE_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -16,22 +10,28 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Definitions for bytecode */ +#ifndef Py_COMPILE_H +#define Py_COMPILE_H +#ifdef __cplusplus +extern "C" { +#endif + /* Bytecode object */ typedef struct { - PyObject_HEAD - int co_argcount; /* #arguments, except *args */ - int co_nlocals; /* #local variables */ - int co_stacksize; /* #entries needed for evaluation stack */ - int co_flags; /* CO_..., see below */ - PyObject *co_code; /* instruction opcodes */ - PyObject *co_consts; /* list (constants used) */ - PyObject *co_names; /* list of strings (names used) */ - PyObject *co_varnames; /* tuple of strings (local variable names) */ - /* The rest doesn't count for hash/cmp */ - PyObject *co_filename; /* string (where it was loaded from) */ - PyObject *co_name; /* string (name, for reference) */ - int co_firstlineno; /* first source line number */ - PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) */ + PyObject_HEAD + int co_argcount; /* #arguments, except *args */ + int co_nlocals; /* #local variables */ + int co_stacksize; /* #entries needed for evaluation stack */ + int co_flags; /* CO_..., see below */ + PyObject *co_code; /* instruction opcodes */ + PyObject *co_consts; /* list (constants used) */ + PyObject *co_names; /* list of strings (names used) */ + PyObject *co_varnames; /* tuple of strings (local variable names) */ + /* The rest doesn't count for hash/cmp */ + PyObject *co_filename; /* string (where it was loaded from) */ + PyObject *co_name; /* string (name, for reference) */ + int co_firstlineno; /* first source line number */ + PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) */ } PyCodeObject; /* Masks for co_flags above */ @@ -48,11 +48,11 @@ extern DL_IMPORT(PyTypeObject) PyCode_Type; /* Public interface */ struct _node; /* Declare the existence of this type */ -DL_IMPORT(PyCodeObject *) PyNode_Compile Py_PROTO((struct _node *, char *)); -DL_IMPORT(PyCodeObject *) PyCode_New Py_PROTO(( +DL_IMPORT(PyCodeObject *) PyNode_Compile(struct _node *, char *); +DL_IMPORT(PyCodeObject *) PyCode_New( int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *, - PyObject *, PyObject *, int, PyObject *)); /* same as struct above */ -DL_IMPORT(int) PyCode_Addr2Line Py_PROTO((PyCodeObject *, int)); + PyObject *, PyObject *, int, PyObject *); /* same as struct above */ +DL_IMPORT(int) PyCode_Addr2Line(PyCodeObject *, int); /* for internal use only */ #define _PyCode_GETCODEPTR(co, pp) \ diff --git a/Include/complexobject.h b/Include/complexobject.h index ef62964..ef5016f 100644 --- a/Include/complexobject.h +++ b/Include/complexobject.h @@ -1,14 +1,14 @@ +/* Complex number structure */ + #ifndef COMPLEXOBJECT_H #define COMPLEXOBJECT_H #ifdef __cplusplus extern "C" { #endif -/* Complex number structure */ - typedef struct { - double real; - double imag; + double real; + double imag; } Py_complex; /* Operations on complex numbers from complexmodule.c */ @@ -20,12 +20,12 @@ typedef struct { #define c_quot _Py_c_quot #define c_pow _Py_c_pow -extern DL_IMPORT(Py_complex) c_sum Py_PROTO((Py_complex, Py_complex)); -extern DL_IMPORT(Py_complex) c_diff Py_PROTO((Py_complex, Py_complex)); -extern DL_IMPORT(Py_complex) c_neg Py_PROTO((Py_complex)); -extern DL_IMPORT(Py_complex) c_prod Py_PROTO((Py_complex, Py_complex)); -extern DL_IMPORT(Py_complex) c_quot Py_PROTO((Py_complex, Py_complex)); -extern DL_IMPORT(Py_complex) c_pow Py_PROTO((Py_complex, Py_complex)); +extern DL_IMPORT(Py_complex) c_sum(Py_complex, Py_complex); +extern DL_IMPORT(Py_complex) c_diff(Py_complex, Py_complex); +extern DL_IMPORT(Py_complex) c_neg(Py_complex); +extern DL_IMPORT(Py_complex) c_prod(Py_complex, Py_complex); +extern DL_IMPORT(Py_complex) c_quot(Py_complex, Py_complex); +extern DL_IMPORT(Py_complex) c_pow(Py_complex, Py_complex); /* Complex object interface */ @@ -36,20 +36,20 @@ real and imaginary parts. */ typedef struct { - PyObject_HEAD - Py_complex cval; + PyObject_HEAD + Py_complex cval; } PyComplexObject; extern DL_IMPORT(PyTypeObject) PyComplex_Type; #define PyComplex_Check(op) ((op)->ob_type == &PyComplex_Type) -extern DL_IMPORT(PyObject *) PyComplex_FromCComplex Py_PROTO((Py_complex)); -extern DL_IMPORT(PyObject *) PyComplex_FromDoubles Py_PROTO((double real, double imag)); +extern DL_IMPORT(PyObject *) PyComplex_FromCComplex(Py_complex); +extern DL_IMPORT(PyObject *) PyComplex_FromDoubles(double real, double imag); -extern DL_IMPORT(double) PyComplex_RealAsDouble Py_PROTO((PyObject *op)); -extern DL_IMPORT(double) PyComplex_ImagAsDouble Py_PROTO((PyObject *op)); -extern DL_IMPORT(Py_complex) PyComplex_AsCComplex Py_PROTO((PyObject *op)); +extern DL_IMPORT(double) PyComplex_RealAsDouble(PyObject *op); +extern DL_IMPORT(double) PyComplex_ImagAsDouble(PyObject *op); +extern DL_IMPORT(Py_complex) PyComplex_AsCComplex(PyObject *op); #ifdef __cplusplus } diff --git a/Include/fileobject.h b/Include/fileobject.h index c30d63b..7c6bfac 100644 --- a/Include/fileobject.h +++ b/Include/fileobject.h @@ -1,9 +1,3 @@ -#ifndef Py_FILEOBJECT_H -#define Py_FILEOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -16,20 +10,26 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* File object interface */ +#ifndef Py_FILEOBJECT_H +#define Py_FILEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + extern DL_IMPORT(PyTypeObject) PyFile_Type; #define PyFile_Check(op) ((op)->ob_type == &PyFile_Type) -extern DL_IMPORT(PyObject *) PyFile_FromString Py_PROTO((char *, char *)); -extern DL_IMPORT(void) PyFile_SetBufSize Py_PROTO((PyObject *, int)); -extern DL_IMPORT(PyObject *) PyFile_FromFile - Py_PROTO((FILE *, char *, char *, int (*)Py_FPROTO((FILE *)))); -extern DL_IMPORT(FILE *) PyFile_AsFile Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyFile_Name Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyFile_GetLine Py_PROTO((PyObject *, int)); -extern DL_IMPORT(int) PyFile_WriteObject Py_PROTO((PyObject *, PyObject *, int)); -extern DL_IMPORT(int) PyFile_SoftSpace Py_PROTO((PyObject *, int)); -extern DL_IMPORT(int) PyFile_WriteString Py_PROTO((char *, PyObject *)); +extern DL_IMPORT(PyObject *) PyFile_FromString(char *, char *); +extern DL_IMPORT(void) PyFile_SetBufSize(PyObject *, int); +extern DL_IMPORT(PyObject *) PyFile_FromFile(FILE *, char *, char *, + int (*)(FILE *)); +extern DL_IMPORT(FILE *) PyFile_AsFile(PyObject *); +extern DL_IMPORT(PyObject *) PyFile_Name(PyObject *); +extern DL_IMPORT(PyObject *) PyFile_GetLine(PyObject *, int); +extern DL_IMPORT(int) PyFile_WriteObject(PyObject *, PyObject *, int); +extern DL_IMPORT(int) PyFile_SoftSpace(PyObject *, int); +extern DL_IMPORT(int) PyFile_WriteString(char *, PyObject *); #ifdef __cplusplus } diff --git a/Include/floatobject.h b/Include/floatobject.h index 2d10467..fd7f9d2 100644 --- a/Include/floatobject.h +++ b/Include/floatobject.h @@ -1,9 +1,3 @@ -#ifndef Py_FLOATOBJECT_H -#define Py_FLOATOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -20,18 +14,24 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. PyFloatObject represents a (double precision) floating point number. */ +#ifndef Py_FLOATOBJECT_H +#define Py_FLOATOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { - PyObject_HEAD - double ob_fval; + PyObject_HEAD + double ob_fval; } PyFloatObject; extern DL_IMPORT(PyTypeObject) PyFloat_Type; #define PyFloat_Check(op) ((op)->ob_type == &PyFloat_Type) -extern DL_IMPORT(PyObject *) PyFloat_FromString Py_PROTO((PyObject*, char**)); -extern DL_IMPORT(PyObject *) PyFloat_FromDouble Py_PROTO((double)); -extern DL_IMPORT(double) PyFloat_AsDouble Py_PROTO((PyObject *)); +extern DL_IMPORT(PyObject *) PyFloat_FromString(PyObject*, char**); +extern DL_IMPORT(PyObject *) PyFloat_FromDouble(double); +extern DL_IMPORT(double) PyFloat_AsDouble(PyObject *); /* Macro, trading safety for speed */ #define PyFloat_AS_DOUBLE(op) (((PyFloatObject *)(op))->ob_fval) diff --git a/Include/frameobject.h b/Include/frameobject.h index 58545fb..5021d4e 100644 --- a/Include/frameobject.h +++ b/Include/frameobject.h @@ -1,9 +1,3 @@ -#ifndef Py_FRAMEOBJECT_H -#define Py_FRAMEOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -16,32 +10,38 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Frame object interface */ +#ifndef Py_FRAMEOBJECT_H +#define Py_FRAMEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { - int b_type; /* what kind of block this is */ - int b_handler; /* where to jump to find handler */ - int b_level; /* value stack level to pop to */ + int b_type; /* what kind of block this is */ + int b_handler; /* where to jump to find handler */ + int b_level; /* value stack level to pop to */ } PyTryBlock; typedef struct _frame { - PyObject_HEAD - struct _frame *f_back; /* previous frame, or NULL */ - PyCodeObject *f_code; /* code segment */ - PyObject *f_builtins; /* builtin symbol table (PyDictObject) */ - PyObject *f_globals; /* global symbol table (PyDictObject) */ - PyObject *f_locals; /* local symbol table (PyDictObject) */ - PyObject **f_valuestack; /* points after the last local */ - PyObject *f_trace; /* Trace function */ - PyObject *f_exc_type, *f_exc_value, *f_exc_traceback; - PyThreadState *f_tstate; - int f_lasti; /* Last instruction if called */ - int f_lineno; /* Current line number */ - int f_restricted; /* Flag set if restricted operations + PyObject_HEAD + struct _frame *f_back; /* previous frame, or NULL */ + PyCodeObject *f_code; /* code segment */ + PyObject *f_builtins; /* builtin symbol table (PyDictObject) */ + PyObject *f_globals; /* global symbol table (PyDictObject) */ + PyObject *f_locals; /* local symbol table (PyDictObject) */ + PyObject **f_valuestack; /* points after the last local */ + PyObject *f_trace; /* Trace function */ + PyObject *f_exc_type, *f_exc_value, *f_exc_traceback; + PyThreadState *f_tstate; + int f_lasti; /* Last instruction if called */ + int f_lineno; /* Current line number */ + int f_restricted; /* Flag set if restricted operations in this scope */ - int f_iblock; /* index in f_blockstack */ - PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ - int f_nlocals; /* number of locals */ - int f_stacksize; /* size of value stack */ - PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ + int f_iblock; /* index in f_blockstack */ + PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ + int f_nlocals; /* number of locals */ + int f_stacksize; /* size of value stack */ + PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ } PyFrameObject; @@ -51,9 +51,8 @@ extern DL_IMPORT(PyTypeObject) PyFrame_Type; #define PyFrame_Check(op) ((op)->ob_type == &PyFrame_Type) -DL_IMPORT(PyFrameObject *) PyFrame_New - Py_PROTO((PyThreadState *, PyCodeObject *, - PyObject *, PyObject *)); +DL_IMPORT(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, + PyObject *, PyObject *); /* The rest of the interface is specific for frame objects */ @@ -80,17 +79,17 @@ DL_IMPORT(PyFrameObject *) PyFrame_New /* Block management functions */ -DL_IMPORT(void) PyFrame_BlockSetup Py_PROTO((PyFrameObject *, int, int, int)); -DL_IMPORT(PyTryBlock *) PyFrame_BlockPop Py_PROTO((PyFrameObject *)); +DL_IMPORT(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int); +DL_IMPORT(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *); /* Extend the value stack */ -DL_IMPORT(PyObject **) PyFrame_ExtendStack Py_PROTO((PyFrameObject *, int, int)); +DL_IMPORT(PyObject **) PyFrame_ExtendStack(PyFrameObject *, int, int); /* Conversions between "fast locals" and locals in dictionary */ -DL_IMPORT(void) PyFrame_LocalsToFast Py_PROTO((PyFrameObject *, int)); -DL_IMPORT(void) PyFrame_FastToLocals Py_PROTO((PyFrameObject *)); +DL_IMPORT(void) PyFrame_LocalsToFast(PyFrameObject *, int); +DL_IMPORT(void) PyFrame_FastToLocals(PyFrameObject *); #ifdef __cplusplus } diff --git a/Include/funcobject.h b/Include/funcobject.h index dc9a942..e85fc1a 100644 --- a/Include/funcobject.h +++ b/Include/funcobject.h @@ -1,9 +1,3 @@ -#ifndef Py_FUNCOBJECT_H -#define Py_FUNCOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -16,24 +10,30 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Function object interface */ +#ifndef Py_FUNCOBJECT_H +#define Py_FUNCOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { - PyObject_HEAD - PyObject *func_code; - PyObject *func_globals; - PyObject *func_defaults; - PyObject *func_doc; - PyObject *func_name; + PyObject_HEAD + PyObject *func_code; + PyObject *func_globals; + PyObject *func_defaults; + PyObject *func_doc; + PyObject *func_name; } PyFunctionObject; extern DL_IMPORT(PyTypeObject) PyFunction_Type; #define PyFunction_Check(op) ((op)->ob_type == &PyFunction_Type) -extern DL_IMPORT(PyObject *) PyFunction_New Py_PROTO((PyObject *, PyObject *)); -extern DL_IMPORT(PyObject *) PyFunction_GetCode Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyFunction_GetGlobals Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyFunction_GetDefaults Py_PROTO((PyObject *)); -extern DL_IMPORT(int) PyFunction_SetDefaults Py_PROTO((PyObject *, PyObject *)); +extern DL_IMPORT(PyObject *) PyFunction_New(PyObject *, PyObject *); +extern DL_IMPORT(PyObject *) PyFunction_GetCode(PyObject *); +extern DL_IMPORT(PyObject *) PyFunction_GetGlobals(PyObject *); +extern DL_IMPORT(PyObject *) PyFunction_GetDefaults(PyObject *); +extern DL_IMPORT(int) PyFunction_SetDefaults(PyObject *, PyObject *); /* Macros for direct access to these values. Type checks are *not* done, so use with care. */ diff --git a/Include/grammar.h b/Include/grammar.h index a15316e..ba67f90 100644 --- a/Include/grammar.h +++ b/Include/grammar.h @@ -1,9 +1,3 @@ -#ifndef Py_GRAMMAR_H -#define Py_GRAMMAR_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -16,13 +10,19 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Grammar interface */ +#ifndef Py_GRAMMAR_H +#define Py_GRAMMAR_H +#ifdef __cplusplus +extern "C" { +#endif + #include "bitset.h" /* Sigh... */ /* A label of an arc */ typedef struct { - int lb_type; - char *lb_str; + int lb_type; + char *lb_str; } label; #define EMPTY 0 /* Label number 0 is by definition the empty label */ @@ -30,72 +30,72 @@ typedef struct { /* A list of labels */ typedef struct { - int ll_nlabels; - label *ll_label; + int ll_nlabels; + label *ll_label; } labellist; /* An arc from one state to another */ typedef struct { - short a_lbl; /* Label of this arc */ - short a_arrow; /* State where this arc goes to */ + short a_lbl; /* Label of this arc */ + short a_arrow; /* State where this arc goes to */ } arc; /* A state in a DFA */ typedef struct { - int s_narcs; - arc *s_arc; /* Array of arcs */ + int s_narcs; + arc *s_arc; /* Array of arcs */ - /* Optional accelerators */ - int s_lower; /* Lowest label index */ - int s_upper; /* Highest label index */ - int *s_accel; /* Accelerator */ - int s_accept; /* Nonzero for accepting state */ + /* Optional accelerators */ + int s_lower; /* Lowest label index */ + int s_upper; /* Highest label index */ + int *s_accel; /* Accelerator */ + int s_accept; /* Nonzero for accepting state */ } state; /* A DFA */ typedef struct { - int d_type; /* Non-terminal this represents */ - char *d_name; /* For printing */ - int d_initial; /* Initial state */ - int d_nstates; - state *d_state; /* Array of states */ - bitset d_first; + int d_type; /* Non-terminal this represents */ + char *d_name; /* For printing */ + int d_initial; /* Initial state */ + int d_nstates; + state *d_state; /* Array of states */ + bitset d_first; } dfa; /* A grammar */ typedef struct { - int g_ndfas; - dfa *g_dfa; /* Array of DFAs */ - labellist g_ll; - int g_start; /* Start symbol of the grammar */ - int g_accel; /* Set if accelerators present */ + int g_ndfas; + dfa *g_dfa; /* Array of DFAs */ + labellist g_ll; + int g_start; /* Start symbol of the grammar */ + int g_accel; /* Set if accelerators present */ } grammar; /* FUNCTIONS */ -grammar *newgrammar Py_PROTO((int start)); -dfa *adddfa Py_PROTO((grammar *g, int type, char *name)); -int addstate Py_PROTO((dfa *d)); -void addarc Py_PROTO((dfa *d, int from, int to, int lbl)); -dfa *PyGrammar_FindDFA Py_PROTO((grammar *g, int type)); -char *typename Py_PROTO((grammar *g, int lbl)); +grammar *newgrammar(int start); +dfa *adddfa(grammar *g, int type, char *name); +int addstate(dfa *d); +void addarc(dfa *d, int from, int to, int lbl); +dfa *PyGrammar_FindDFA(grammar *g, int type); +char *typename(grammar *g, int lbl); -int addlabel Py_PROTO((labellist *ll, int type, char *str)); -int findlabel Py_PROTO((labellist *ll, int type, char *str)); -char *PyGrammar_LabelRepr Py_PROTO((label *lb)); -void translatelabels Py_PROTO((grammar *g)); +int addlabel(labellist *ll, int type, char *str); +int findlabel(labellist *ll, int type, char *str); +char *PyGrammar_LabelRepr(label *lb); +void translatelabels(grammar *g); -void addfirstsets Py_PROTO((grammar *g)); +void addfirstsets(grammar *g); -void PyGrammar_AddAccelerators Py_PROTO((grammar *g)); -void PyGrammar_RemoveAccelerators Py_PROTO((grammar *)); +void PyGrammar_AddAccelerators(grammar *g); +void PyGrammar_RemoveAccelerators(grammar *); -void printgrammar Py_PROTO((grammar *g, FILE *fp)); -void printnonterminals Py_PROTO((grammar *g, FILE *fp)); +void printgrammar(grammar *g, FILE *fp); +void printnonterminals(grammar *g, FILE *fp); #ifdef __cplusplus } diff --git a/Include/intobject.h b/Include/intobject.h index 50a7474..925e19a 100644 --- a/Include/intobject.h +++ b/Include/intobject.h @@ -1,9 +1,3 @@ -#ifndef Py_INTOBJECT_H -#define Py_INTOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -29,20 +23,26 @@ The type PyIntObject is (unfortunately) exposed here so we can declare _Py_TrueStruct and _Py_ZeroStruct below; don't use this. */ +#ifndef Py_INTOBJECT_H +#define Py_INTOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { - PyObject_HEAD - long ob_ival; + PyObject_HEAD + long ob_ival; } PyIntObject; extern DL_IMPORT(PyTypeObject) PyInt_Type; #define PyInt_Check(op) ((op)->ob_type == &PyInt_Type) -extern DL_IMPORT(PyObject *) PyInt_FromString Py_PROTO((char*, char**, int)); -extern DL_IMPORT(PyObject *) PyInt_FromUnicode Py_PROTO((Py_UNICODE*, int, int)); -extern DL_IMPORT(PyObject *) PyInt_FromLong Py_PROTO((long)); -extern DL_IMPORT(long) PyInt_AsLong Py_PROTO((PyObject *)); -extern DL_IMPORT(long) PyInt_GetMax Py_PROTO((void)); +extern DL_IMPORT(PyObject *) PyInt_FromString(char*, char**, int); +extern DL_IMPORT(PyObject *) PyInt_FromUnicode(Py_UNICODE*, int, int); +extern DL_IMPORT(PyObject *) PyInt_FromLong(long); +extern DL_IMPORT(long) PyInt_AsLong(PyObject *); +extern DL_IMPORT(long) PyInt_GetMax(void); /* @@ -68,8 +68,8 @@ extern DL_IMPORT(PyIntObject) _Py_ZeroStruct, _Py_TrueStruct; /* Don't use these * into the main Python shared library/DLL. Guido thinks I'm weird for * building it this way. :-) [cjh] */ -extern DL_IMPORT(unsigned long) PyOS_strtoul Py_PROTO((char *, char **, int)); -extern DL_IMPORT(long) PyOS_strtol Py_PROTO((char *, char **, int)); +extern DL_IMPORT(unsigned long) PyOS_strtoul(char *, char **, int); +extern DL_IMPORT(long) PyOS_strtol(char *, char **, int); #ifdef __cplusplus } diff --git a/Include/listobject.h b/Include/listobject.h index e6f008e..0fea447 100644 --- a/Include/listobject.h +++ b/Include/listobject.h @@ -1,9 +1,3 @@ -#ifndef Py_LISTOBJECT_H -#define Py_LISTOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -28,26 +22,32 @@ inserted in the list. Similarly, PyList_GetItem does not increment the returned item's reference count. */ +#ifndef Py_LISTOBJECT_H +#define Py_LISTOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + typedef struct { - PyObject_VAR_HEAD - PyObject **ob_item; + PyObject_VAR_HEAD + PyObject **ob_item; } PyListObject; extern DL_IMPORT(PyTypeObject) PyList_Type; #define PyList_Check(op) ((op)->ob_type == &PyList_Type) -extern DL_IMPORT(PyObject *) PyList_New Py_PROTO((int size)); -extern DL_IMPORT(int) PyList_Size Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyList_GetItem Py_PROTO((PyObject *, int)); -extern DL_IMPORT(int) PyList_SetItem Py_PROTO((PyObject *, int, PyObject *)); -extern DL_IMPORT(int) PyList_Insert Py_PROTO((PyObject *, int, PyObject *)); -extern DL_IMPORT(int) PyList_Append Py_PROTO((PyObject *, PyObject *)); -extern DL_IMPORT(PyObject *) PyList_GetSlice Py_PROTO((PyObject *, int, int)); -extern DL_IMPORT(int) PyList_SetSlice Py_PROTO((PyObject *, int, int, PyObject *)); -extern DL_IMPORT(int) PyList_Sort Py_PROTO((PyObject *)); -extern DL_IMPORT(int) PyList_Reverse Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyList_AsTuple Py_PROTO((PyObject *)); +extern DL_IMPORT(PyObject *) PyList_New(int size); +extern DL_IMPORT(int) PyList_Size(PyObject *); +extern DL_IMPORT(PyObject *) PyList_GetItem(PyObject *, int); +extern DL_IMPORT(int) PyList_SetItem(PyObject *, int, PyObject *); +extern DL_IMPORT(int) PyList_Insert(PyObject *, int, PyObject *); +extern DL_IMPORT(int) PyList_Append(PyObject *, PyObject *); +extern DL_IMPORT(PyObject *) PyList_GetSlice(PyObject *, int, int); +extern DL_IMPORT(int) PyList_SetSlice(PyObject *, int, int, PyObject *); +extern DL_IMPORT(int) PyList_Sort(PyObject *); +extern DL_IMPORT(int) PyList_Reverse(PyObject *); +extern DL_IMPORT(PyObject *) PyList_AsTuple(PyObject *); /* Macro, trading safety for speed */ #define PyList_GET_ITEM(op, i) (((PyListObject *)(op))->ob_item[i]) diff --git a/Include/methodobject.h b/Include/methodobject.h index c01e8a8..ace58d3 100644 --- a/Include/methodobject.h +++ b/Include/methodobject.h @@ -1,9 +1,3 @@ -#ifndef Py_METHODOBJECT_H -#define Py_METHODOBJECT_H -#ifdef __cplusplus -extern "C" { -#endif - /*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. @@ -16,6 +10,12 @@ redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. /* Method object interface */ +#ifndef Py_METHODOBJECT_H +#define Py_METHODOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + extern DL_IMPORT(PyTypeObject) PyCFunction_Type; #define PyCFunction_Check(op) ((op)->ob_type == &PyCFunction_Type) @@ -24,9 +24,9 @@ typedef PyObject *(*PyCFunction) Py_FPROTO((PyObject *, PyObject *)); typedef PyObject *(*PyCFunctionWithKeywords) Py_FPROTO((PyObject *, PyObject *, PyObject *)); -extern DL_IMPORT(PyCFunction) PyCFunction_GetFunction Py_PROTO((PyObject *)); -extern DL_IMPORT(PyObject *) PyCFunction_GetSelf Py_PROTO((PyObject *)); -extern DL_IMPORT(int) PyCFunction_GetFlags Py_PROTO((PyObject *)); +extern DL_IMPORT(PyCFunction) PyCFunction_GetFunction(PyObject *); +extern DL_IMPORT(PyObject *) PyCFunction_GetSelf(PyObject *); +extern DL_IMPORT(int) PyCFunction_GetFlags(PyObject *); /* Macros for direct access to these values. Type checks are *not* done, so use with care. */ @@ -38,35 +38,33 @@ extern DL_IMPORT(int) PyCFunction_GetFlags Py_PROTO((PyObject *)); (((PyCFunctionObject *)func) -> m_ml -> ml_flags) struct PyMethodDef { - char *ml_name; - PyCFunction ml_meth; - int ml_flags; - char *ml_doc; + char *ml_name; + PyCFunction ml_meth; + int ml_flags; + char *ml_doc; }; typedef struct PyMethodDef PyMethodDef; -extern DL_IMPORT(PyObject *) Py_FindMethod - Py_PROTO((PyMethodDef[], PyObject *, char *)); +extern DL_IMPORT(PyObject *) Py_FindMethod(PyMethodDef[], PyObject *, char *); -extern DL_IMPORT(PyObject *) PyCFunction_New - Py_PROTO((PyMethodDef *, PyObject *)); +extern DL_IMPORT(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *); /* Flag passed to newmethodobject */ #define METH_VARARGS 0x0001 #define METH_KEYWORDS 0x0002 typedef struct PyMethodChain { - PyMethodDef *methods; /* Methods of this type */ - struct PyMethodChain *link; /* NULL or base type */ + PyMethodDef *methods; /* Methods of this type */ + struct PyMethodChain *link; /* NULL or base type */ } PyMethodChain; -extern DL_IMPORT(PyObject *) Py_FindMethodInChain - Py_PROTO((PyMethodChain *, PyObject *, char *)); +extern DL_IMPORT(PyObject *) Py_FindMethodInChain(PyMethodChain *, PyObject *, + char *); typedef struct { - PyObject_HEAD - PyMethodDef *m_ml; - PyObject *m_self; + PyObject_HEAD + PyMethodDef *m_ml; + PyObject *m_self; } PyCFunctionObject; #ifdef __cplusplus |